primocode 9.8.0-beta.7 → 9.8.0-beta.9

package/lib/fala.js

@@ -37,9 +37,95 @@
 
 'use strict';
 
+const { EventEmitter } = require('events');
 const { c, actionHeader, friendlyError } = require('./ui');
 const markdown = require('./markdown.js');
 
+/* ── O CANAL ESTRUTURADO ─────────────────────────────────────────────────
+ * A janela do app (lib/app.js) mostra a conversa como CHAT: a fala do Primo
+ * em texto e cada ação dele numa linha cinza ("Leu index.html", "Rodou npm
+ * test ✓"). Adivinhar isso relendo a saída colorida do terminal seria frágil
+ * — um rótulo que muda aqui quebraria a janela calado. Então a MESMA função
+ * que desenha no terminal também avisa, por este canal, o que desenhou.
+ *
+ * Sem ouvinte (terminal puro), `avisar` não faz nada: nenhum custo para quem
+ * não abriu a janela. */
+const eventos = new EventEmitter();
+eventos.setMaxListeners(20);
+function avisar(tipo, dados) {
+    if (!eventos.listenerCount('evento')) return;
+    try { eventos.emit('evento', Object.assign({ tipo }, dados || {})); } catch { /* a janela nunca derruba o agente */ }
+}
+
+/* O que a linha de ação da janela diz, por ferramenta. Verbo no passado
+   porque a linha fica na conversa depois que a ação acabou — "Lendo" viraria
+   mentira um segundo depois. O ícone é uma família, não um desenho por tool:
+   a página tem dez ícones, não setenta. */
+const VERBOS = {
+    read_file: ['Leu', 'ler'], write_file: ['Escreveu', 'escrever'], edit_file: ['Editou', 'editar'],
+    multi_edit: ['Editou', 'editar'], list_dir: ['Listou', 'buscar'], glob: ['Procurou', 'buscar'],
+    grep: ['Buscou', 'buscar'], run_shell: ['Rodou', 'rodar'], run_in_new_terminal: ['Abriu um terminal com', 'rodar'],
+    open_in_browser: ['Abriu', 'web'], spawn_agent: ['Chamou um agente', 'agente'], write_todos: ['Planejou', 'plano'],
+    finish: ['Concluiu', 'plano'], pesquisar_referencia: ['Pesquisou', 'web'], remember_general: ['Guardou na memória', 'plano'],
+    planejar_producao: ['Planejou a produção', 'agente'], construir_app: ['Construiu', 'agente'],
+};
+
+/** Verbo, alvo e ícone de uma ação — só o que cabe numa linha, nunca o
+ *  conteúdo inteiro de um write_file. */
+function resumoDaAcao(name, args) {
+    const a = args || {};
+    let [verbo, icone] = VERBOS[name] || [];
+    if (!verbo) {
+        if (/^browser_/.test(name)) { verbo = 'Navegador · ' + name.slice(8); icone = 'web'; }
+        else if (/^desktop_/.test(name)) { verbo = 'Computador · ' + name.slice(8).replace(/_/g, ' '); icone = 'computador'; }
+        else if (/^estudio_/.test(name)) { verbo = 'Estúdio · ' + name.slice(8); icone = 'agente'; }
+        else { verbo = name; icone = 'outro'; }
+    }
+    let alvo = a.path || a.command || a.pattern || a.consulta || a.url || a.target || a.app || a.selector
+        || a.titulo || a.description || a.arquivo || (a.todos ? `${a.todos.length} tarefas` : '') || '';
+    if (typeof alvo !== 'string') alvo = '';
+    alvo = alvo.replace(/\s+/g, ' ').trim();
+    if (alvo.length > 120) alvo = alvo.slice(0, 119) + '…';
+    return { nome: name, verbo, alvo, icone };
+}
+
+/** O resultado de uma ação, resumido para a linha da janela: ok ou não, o
+ *  "+12 −3" das edições e até 40 linhas de detalhe para quem expandir. */
+function resumoDoResultado(name, r) {
+    if (!r || typeof r !== 'object') return { nome: name, ok: true };
+    if (r.ok === false) {
+        return { nome: name, ok: false, resumo: String(r.error || `exit ${r.code ?? 'erro'}`).replace(/\s+/g, ' ').trim().slice(0, 300) };
+    }
+    const fora = { nome: name, ok: true };
+    if (typeof r._antes === 'string' && typeof r._depois === 'string') {
+        try {
+            const diff = require('./diff.js');
+            const n = r._antes.split('\n').length + r._depois.split('\n').length;
+            if (n <= diff.MAX_LINHAS_ARQUIVO * 2) {
+                const ops = diff.operacoes(r._antes, r._depois);
+                Object.assign(fora, diff.contar(ops));
+                fora.detalhe = ops.filter((o) => o.tipo !== ' ').slice(0, 40).map((o) => o.tipo + ' ' + o.texto).join('\n');
+            }
+        } catch { /* sem diff: a linha sai sem os números */ }
+    }
+    if (name === 'write_file') fora.criado = !!r.created;
+    if (name === 'run_shell' || name === 'run_in_new_terminal') {
+        const saida = String(r.stdout || '').trim() + (r.stderr ? '\n' + String(r.stderr).trim() : '');
+        fora.detalhe = saida.split('\n').slice(-40).join('\n').trim();
+        fora.codigo = r.code ?? 0;
+    }
+    const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
+    if (name === 'read_file') fora.resumo = plural(r.linhas || 0, 'linha', 'linhas');
+    if (name === 'grep') fora.resumo = plural(r.total || 0, 'ocorrência', 'ocorrências');
+    if (name === 'glob') fora.resumo = plural(r.total || 0, 'arquivo', 'arquivos');
+    if (name === 'list_dir' && r.tree) fora.detalhe = String(r.tree).split('\n').slice(0, 40).join('\n');
+    if (name === 'write_todos' && Array.isArray(r.todos)) {
+        fora.detalhe = r.todos.map((t) => (t.status === 'completed' ? '✓ ' : '○ ') + t.content).join('\n');
+        fora.resumo = `${r.feitos}/${r.total}`;
+    }
+    return fora;
+}
+
 /* Até este tamanho, o texto que o modelo escreve antes de chamar uma tool é
    guardado e sai de uma vez, como pensamento. Passou disso sem tool à vista,
    é resposta — e volta a correr na tela conforme chega. Uma frase de
@@ -58,6 +144,7 @@ function pensamento(texto, profundidade) {
     if (!ls.length || !ls[0]) return '';
     const p = ident(profundidade);
     const saida = ls.map((l, i) => `${p}  ${i === 0 ? c.dim('✦') : ' '} ${c.muted(l)}`).join('\n');
+    avisar('pensamento', { texto: ls.join('\n'), prof: profundidade || 0 });
     console.log(saida);
     return saida;
 }
@@ -65,6 +152,7 @@ function pensamento(texto, profundidade) {
 /** A ação (tool) que ele decidiu fazer. */
 function acao(name, args, profundidade) {
     const saida = ident(profundidade) + actionHeader(name, args);
+    avisar('acao', Object.assign(resumoDaAcao(name, args), { prof: profundidade || 0 }));
     console.log(saida);
     return saida;
 }
@@ -102,6 +190,7 @@ function resposta(texto) {
     const largura = Math.max(40, (process.stdout.columns || 80) - 4);
     const linhasMd = markdown.renderizar(texto, largura);
     const saida = '\n' + linhasMd.map((l, i) => (i === 0 ? `${c.brand('●')} ${l}` : `  ${l}`)).join('\n');
+    avisar('resposta', { texto: String(texto) });
     console.log(saida);
     return saida;
 }
@@ -111,6 +200,7 @@ function resposta(texto) {
 function aviso(texto) {
     if (!String(texto || '').trim()) return '';
     const saida = '\n' + formatar(texto, c.warn('●'));
+    avisar('aviso', { texto: String(texto) });
     console.log(saida);
     return saida;
 }
@@ -154,9 +244,11 @@ function fluxo() {
         escrever(delta) {
             const t = String(delta || '');
             if (!t) return;
+            avisar('pedaco', { texto: t });
             sair(desenho.pedaco(t));
         },
         fechar() {
+            avisar('fim', {});
             sair(desenho.fim());
             if (escreveu) process.stdout.write('\n');
         },
@@ -174,6 +266,7 @@ function paralelo(quantos, profundidade) {
 /** Um agente delegado começando: "◆ Agente·frontend  a folha de estilo". */
 function agente(rotulo, descricao, profundidade) {
     const saida = `${ident(profundidade)}  ${c.brand('◆')} ${c.bold(rotulo || 'Agente')}${descricao ? '  ' + c.muted(descricao) : ''}`;
+    avisar('acao', { nome: 'agente', verbo: rotulo || 'Agente', alvo: String(descricao || '').slice(0, 120), icone: 'agente', prof: profundidade || 0 });
     console.log(saida);
     return saida;
 }
@@ -182,8 +275,9 @@ function agente(rotulo, descricao, profundidade) {
 function agenteVoltou(resumo, profundidade) {
     const texto = String(resumo || 'sem resultado').replace(/\s+/g, ' ').trim();
     const saida = resultado(profundidade) + c.muted(texto.length > 140 ? texto.slice(0, 139) + '…' : texto);
+    avisar('resultado', { nome: 'agente', ok: true, detalhe: texto.slice(0, 2000) });
     console.log(saida);
     return saida;
 }
 
-module.exports = { LIMIAR_PENSAMENTO, pensamento, acao, resultado, recuo, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };
+module.exports = { eventos, avisar, resumoDaAcao, resumoDoResultado, LIMIAR_PENSAMENTO, pensamento, acao, resultado, recuo, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };

package/lib/offline.js

@@ -0,0 +1,168 @@
+/**
+ * offline.js — o primocode-server rodando AQUI, no computador da pessoa.
+ *
+ *   "Como eu não tenho acesso ao Railway, enquanto isso eu posso testar com o
+ *    projeto rodando localmente, chamando as APIs pelo meu computador."
+ *   (24/09/2026)
+ *
+ * O /offline sobe o servidor da pasta primocode-server com as MESMAS chaves
+ * que o Render usa (coladas em ~/.primocode/servidor.env) e aponta o CLI para
+ * ele até a sessão acabar. É temporário: serve para testar o servidor novo
+ * antes de ele ir para produção.
+ *
+ * "Offline" é o nome que o pedido deu, e ele mente um pouco: as IAs continuam
+ * na internet. O que sai do caminho é o servidor de produção.
+ *
+ * ── O QUE NUNCA APARECE ──────────────────────────────────────────────────
+ * O valor de uma chave. Mostram-se só os NOMES das variáveis que o arquivo
+ * tem, o bastante para ver o que falta.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const { spawn } = require('child_process');
+
+const PORTA = Number(process.env.PRIMOCODE_OFFLINE_PORTA || 3190);
+const CASA = path.join(os.homedir(), '.primocode');
+const ARQUIVO_ENV = path.join(CASA, 'servidor.env');
+const ARQUIVO_LOG = path.join(CASA, 'servidor-local.log');
+
+// As variáveis que o primocode-server lê. As de chave vêm primeiro: sem pelo
+// menos uma delas, o servidor sobe mas não tem com quem falar.
+const CHAVES = ['GROQ_API_KEY', 'OPENROUTER_API_KEY', 'GEMINI_API_KEY', 'GOOGLE_API_KEY', 'COHERE_API_KEY', 'HF_TOKEN', 'HUGGINGFACE_API_KEY', 'PG_GATEWAY_API_KEY'];
+const OUTRAS = ['PG_GATEWAY_BASE_URL', 'CONECTA_API', 'PRIMOCODE_TOKEN', 'REQUIRE_TOKEN', 'RATE_LIMIT_PER_HOUR'];
+
+const MODELO_ENV = `# As chaves do primocode-server rodando no seu computador (/offline).
+# Copie do Render: o serviço primocode-server → Environment. Uma por linha,
+# NOME=valor, sem aspas. Este arquivo é só seu: não mande para ninguém.
+#
+${CHAVES.map((k) => `# ${k}=`).join('\n')}
+#
+${OUTRAS.map((k) => `# ${k}=`).join('\n')}
+`;
+
+/** Lê um .env simples: NOME=valor, # comenta, aspas em volta saem. */
+function lerEnv(texto) {
+    const env = {};
+    for (const linha of String(texto || '').split(/\r?\n/)) {
+        const m = linha.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/);
+        if (!m) continue;
+        let valor = m[2];
+        if (/^(['"]).*\1$/.test(valor)) valor = valor.slice(1, -1);
+        if (valor) env[m[1]] = valor;
+    }
+    return env;
+}
+
+/** O arquivo de chaves: cria o modelo (vazio, 600) na primeira vez. */
+function prepararEnv(arquivo = ARQUIVO_ENV) {
+    let criado = false;
+    if (!fs.existsSync(arquivo)) {
+        fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+        fs.writeFileSync(arquivo, MODELO_ENV, { mode: 0o600 });
+        criado = true;
+    }
+    const env = lerEnv(fs.readFileSync(arquivo, 'utf8'));
+    return { arquivo, criado, env, nomes: Object.keys(env), temChave: CHAVES.some((k) => env[k]) };
+}
+
+function ehServidor(dir) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        return pkg.name === 'primocode-server' && fs.existsSync(path.join(dir, 'server.js'));
+    } catch { return false; }
+}
+
+/** Onde está a pasta do primocode-server. A primeira que existir ganha. */
+function acharServidor({ pedido = '', raizCli = path.join(__dirname, '..') } = {}) {
+    const candidatos = [
+        pedido,
+        process.env.PRIMOCODE_SERVER_DIR,
+        path.join(raizCli, '..', 'primocode-server'),
+        path.join(os.homedir(), 'Primocode CLI', 'primocode-server'),
+        path.join(os.homedir(), 'primocode-server'),
+    ].filter(Boolean).map((p) => path.resolve(p.replace(/^~(?=$|\/)/, os.homedir())));
+    return candidatos.find(ehServidor) || null;
+}
+
+/** GET /health; devolve o JSON ou null. */
+function saude(url, espera = 1500) {
+    return new Promise((resolve) => {
+        const req = http.get(url + '/health', { timeout: espera }, (res) => {
+            let corpo = '';
+            res.on('data', (d) => { corpo += d; });
+            res.on('end', () => { try { resolve(JSON.parse(corpo)); } catch { resolve(null); } });
+        });
+        req.on('timeout', () => req.destroy());
+        req.on('error', () => resolve(null));
+    });
+}
+
+let filho = null;
+
+/**
+ * Sobe o servidor (ou reaproveita um que já responde na porta).
+ * Devolve { ok, url, versao, reaproveitado } ou { ok: false, error, comoResolver }.
+ */
+async function ligar({ dir, env = {}, porta = PORTA, log = ARQUIVO_LOG, prazo = 20000 } = {}) {
+    const url = `http://localhost:${porta}`;
+    const ja = await saude(url);
+    if (ja && ja.status === 'ok') return { ok: true, url, versao: ja.version, reaproveitado: true };
+    if (!dir) {
+        return {
+            ok: false,
+            error: 'Não achei a pasta do primocode-server.',
+            comoResolver: 'clone o repo ao lado do primocode, ou diga onde ele está: /offline ~/caminho/primocode-server',
+        };
+    }
+    if (!fs.existsSync(path.join(dir, 'node_modules'))) {
+        return {
+            ok: false,
+            error: `O servidor em ${dir} ainda não tem as dependências.`,
+            comoResolver: `rode uma vez: cd "${dir}" && npm install`,
+        };
+    }
+    fs.mkdirSync(path.dirname(log), { recursive: true });
+    const saida = fs.openSync(log, 'a');
+    filho = spawn(process.execPath, ['server.js'], {
+        cwd: dir,
+        env: { ...process.env, ...env, PORT: String(porta) },
+        stdio: ['ignore', saida, saida],
+    });
+    let morreu = null;
+    filho.on('exit', (codigo) => { morreu = codigo; filho = null; });
+
+    const fim = Date.now() + prazo;
+    while (Date.now() < fim) {
+        if (morreu !== null) {
+            return { ok: false, error: `O servidor fechou sozinho (código ${morreu}).`, comoResolver: `veja o fim de ${log}` };
+        }
+        const h = await saude(url);
+        if (h && h.status === 'ok') return { ok: true, url, versao: h.version, reaproveitado: false };
+        await new Promise((r) => setTimeout(r, 300));
+    }
+    desligar();
+    return { ok: false, error: `O servidor não respondeu em ${Math.round(prazo / 1000)}s.`, comoResolver: `veja o fim de ${log}` };
+}
+
+/** Desliga o servidor que ESTE processo subiu. Um reaproveitado fica de pé. */
+function desligar() {
+    if (!filho) return false;
+    try { filho.kill(); } catch {}
+    filho = null;
+    return true;
+}
+
+function ligado() { return Boolean(filho); }
+
+// O servidor não pode sobrar rodando quando o CLI fecha.
+process.on('exit', desligar);
+
+module.exports = {
+    PORTA, ARQUIVO_ENV, ARQUIVO_LOG, CHAVES,
+    lerEnv, prepararEnv, acharServidor, ehServidor, saude, ligar, desligar, ligado,
+};

package/lib/{ide.js → painel.js}

@@ -1,27 +1,30 @@
 /**
- * ide.js — a PrimoCode IDE: árvore, editor, prévia e chat, na mesma janela.
+ * painel.js — o painel da direita da janela: a prévia do site e os arquivos.
  *
- *   "Um app ao invés de CLI, aí fica uma IDE e uma CLI."
+ *   "Remove a IDE ou deixa idêntico ao Codex."
  *
- * ── POR QUE MORA DENTRO DO SERVIDOR DO /rc ───────────────────────────────
- * A janela do /rc já resolveu o difícil: servidor em 127.0.0.1 com chave
- * sorteada, fluxo de eventos (SSE) ao vivo e o espelho da saída do terminal.
- * Uma IDE com servidor próprio seria uma segunda chave, uma segunda porta e um
- * segundo fluxo — e as duas janelas mostrariam agentes que parecem diferentes
- * sendo o mesmo. Aqui só entram as rotas que a IDE precisa a mais (árvore,
- * ler, salvar, prévia) e o vigia da pasta, que empurra eventos pelo MESMO
- * fluxo do /rc.
+ * Antes isto era a PrimoCode IDE: árvore, EDITOR de código, prévia e chat. O
+ * editor saiu. Quem usa o PrimoCode não programa — um editor de código na
+ * cara dessa pessoa é uma porta para quebrar o que o agente fez, sem saber
+ * como voltar. O que ficou é o que ela usa de verdade: ver o site que está
+ * nascendo (Prévia) e olhar o que tem na pasta (Arquivos), só leitura.
+ *
+ * ── POR QUE MORA DENTRO DO SERVIDOR DA JANELA ────────────────────────────
+ * A janela (lib/app.js) já resolveu o difícil: 127.0.0.1, chave sorteada e o
+ * fluxo de eventos (SSE). Aqui só entram as rotas do painel (árvore, ler,
+ * prévia) e o vigia da pasta, que empurra "arquivo mudou" pelo MESMO fluxo —
+ * é o que faz a prévia recarregar enquanto o agente escreve.
  *
  * ── SEGURANÇA ────────────────────────────────────────────────────────────
- * Estas rotas leem e ESCREVEM no disco do usuário. Três travas:
  *   · a chave do app.js vale aqui também (tudo mora em /api/);
  *   · todo caminho é resolvido DENTRO da pasta do projeto — "../", caminho
  *     absoluto e link simbólico que aponta para fora são recusados;
+ *   · nada aqui escreve no disco: sem editor, não há rota de salvar;
  *   · a prévia roda num iframe sandbox SEM allow-same-origin, e o servidor
  *     manda o mesmo sandbox no cabeçalho. O código da prévia foi escrito pelo
- *     agente (ou pela pessoa); se ele herdasse a origem da IDE, poderia chamar
- *     /api/enviar e dar ordens ao agente. Com origem opaca, o fetch dele sai
- *     com `Origin: null` e o app.js recusa.
+ *     agente; se ele herdasse a origem da janela, poderia chamar /api/enviar
+ *     e dar ordens ao agente. Com origem opaca, o fetch dele sai com
+ *     `Origin: null` e o app.js recusa.
  */
 
 'use strict';
@@ -36,9 +39,9 @@ const IGNORADOS = new Set(['node_modules', '.git', '.DS_Store', '.next', '.cache
     '__pycache__', '.venv', 'venv', '.turbo', '.parcel-cache']);
 const MAX_ITENS = 4000;
 const MAX_PROFUNDIDADE = 12;
-// 1 MB: acima disso um <textarea> engasga a cada tecla, e arquivo desse
-// tamanho num projeto de iniciante é quase sempre gerado (bundle, dado).
-const MAX_EDITOR = 1024 * 1024;
+// 1 MB: acima disso o visualizador engasga, e arquivo desse tamanho num
+// projeto de iniciante é quase sempre gerado (bundle, dado).
+const MAX_LEITURA = 1024 * 1024;
 
 // ── caminhos ─────────────────────────────────────────────────────────────
 
@@ -46,12 +49,12 @@ const MAX_EDITOR = 1024 * 1024;
  *
  * `path.relative` pega o "../" e o caminho absoluto; o `realpath` pega o link
  * simbólico, que passa pelo primeiro teste com cara de arquivo de dentro e
- * aponta para ~/.ssh. Arquivo que ainda não existe (salvar um novo) é checado
+ * aponta para ~/.ssh. Caminho que ainda não existe é checado
  * pela pasta onde vai nascer. */
 function dentro(raiz, relativo) {
     if (typeof relativo !== 'string' || relativo.includes('\0')) return null;
     // Absoluto é recusado de cara, e não "reinterpretado" como relativo:
-    // quem manda /etc/hosts quer o /etc/hosts, e salvar em <projeto>/etc/hosts
+    // quem manda /etc/hosts quer o /etc/hosts, e ler <projeto>/etc/hosts
     // no lugar seria uma surpresa. `C:\` e `\\servidor` também contam.
     if (path.isAbsolute(relativo) || path.win32.isAbsolute(relativo)) return null;
     const base = path.resolve(raiz);
@@ -113,11 +116,10 @@ function arvore(raiz) {
     return { itens, cortada };
 }
 
-// ── ler e salvar ─────────────────────────────────────────────────────────
+// ── ler ──────────────────────────────────────────────────────────────────
 
 /* Binário é o que tem byte zero nos primeiros 8 KB — o mesmo teste do git.
-   Mostrar um PNG como texto no editor e deixar a pessoa salvar por cima
-   destruiria a imagem sem aviso. */
+   Mostrar um PNG como texto é uma tela de lixo que parece arquivo quebrado. */
 function ehBinario(buf) {
     const n = Math.min(buf.length, 8000);
     for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
@@ -131,35 +133,12 @@ function ler(raiz, rel) {
     try { st = fs.statSync(abs); } catch { return { status: 404, corpo: { ok: false, error: 'não existe' } }; }
     if (!st.isFile()) return { status: 400, corpo: { ok: false, error: 'não é arquivo' } };
     const base = { ok: true, caminho: relativoDe(raiz, abs), tamanho: st.size, mtime: st.mtimeMs };
-    if (st.size > MAX_EDITOR) return { status: 200, corpo: Object.assign(base, { grande: true }) };
+    if (st.size > MAX_LEITURA) return { status: 200, corpo: Object.assign(base, { grande: true }) };
     const buf = fs.readFileSync(abs);
     if (ehBinario(buf)) return { status: 200, corpo: Object.assign(base, { binario: true }) };
     return { status: 200, corpo: Object.assign(base, { conteudo: buf.toString('utf8') }) };
 }
 
-/* `mtimeBase` é o mtime que a página viu ao abrir o arquivo. Se o disco está
-   mais novo, alguém (quase sempre o agente) mexeu no meio — e salvar por cima
-   apagaria o trabalho dele sem ninguém perceber. A página decide: recarregar
-   ou mandar de novo com `forcar`. */
-function salvar(raiz, dados) {
-    const rel = dados && dados.caminho;
-    const conteudo = dados && dados.conteudo;
-    if (typeof conteudo !== 'string') return { status: 400, corpo: { ok: false, error: 'conteúdo faltando' } };
-    if (Buffer.byteLength(conteudo) > MAX_EDITOR) return { status: 413, corpo: { ok: false, error: 'maior que 1 MB' } };
-    const abs = dentro(raiz, rel);
-    if (!abs || abs === path.resolve(raiz)) return { status: 403, corpo: { ok: false, error: 'fora da pasta do projeto' } };
-    if (ignorado(relativoDe(raiz, abs))) return { status: 403, corpo: { ok: false, error: 'pasta protegida' } };
-    let st = null;
-    try { st = fs.statSync(abs); } catch { /* arquivo novo */ }
-    if (st && !st.isFile()) return { status: 400, corpo: { ok: false, error: 'não é arquivo' } };
-    if (st && dados.mtimeBase && !dados.forcar && st.mtimeMs > Number(dados.mtimeBase) + 1) {
-        return { status: 409, corpo: { ok: false, conflito: true, error: 'mudou no disco depois que você abriu', mtime: st.mtimeMs } };
-    }
-    fs.mkdirSync(path.dirname(abs), { recursive: true });
-    fs.writeFileSync(abs, conteudo);
-    return { status: 200, corpo: { ok: true, caminho: relativoDe(raiz, abs), mtime: fs.statSync(abs).mtimeMs } };
-}
-
 // ── prévia ───────────────────────────────────────────────────────────────
 
 const TIPOS = {
@@ -193,7 +172,7 @@ function servirPrevia(raiz, rel, res) {
         'Content-Type': TIPOS[path.extname(alvo).toLowerCase()] || 'application/octet-stream',
         'Cache-Control': 'no-store',
         // O mesmo sandbox do iframe, dito pelo servidor: vale até se alguém
-        // abrir o endereço da prévia fora da IDE.
+        // abrir o endereço da prévia fora da janela.
         'Content-Security-Policy': 'sandbox allow-scripts allow-forms allow-modals allow-popups allow-pointer-lock',
     });
     fs.createReadStream(alvo).pipe(res);
@@ -237,7 +216,7 @@ function vigiar(raiz, aoMudar, espera = 150) {
 // ── as rotas ─────────────────────────────────────────────────────────────
 
 /**
- * Monta a IDE num servidor do app.js.
+ * Monta o painel num servidor do app.js.
  *
  * @param {object} op
  * @param {()=>string} op.pasta   a pasta do projeto AGORA (o /dir muda ela)
@@ -247,9 +226,6 @@ function vigiar(raiz, aoMudar, espera = 150) {
 function montar(op) {
     let pastaVigiada = null;
     let pararVigia = () => {};
-    // O que a própria IDE acabou de salvar, para a página não pintar como
-    // "o agente mexeu" a mudança que a pessoa fez.
-    const salvosAgora = new Map();
 
     function conferirPasta() {
         const atual = op.pasta && op.pasta();
@@ -257,19 +233,14 @@ function montar(op) {
         pararVigia();
         pastaVigiada = atual;
         if (!fs.existsSync(atual)) { pararVigia = () => {}; return atual; }
-        pararVigia = vigiar(atual, (mudados) => {
-            const agora = Date.now();
-            const deVoce = mudados.filter((m) => (salvosAgora.get(m) || 0) > agora - 1500);
-            op.emitir('arquivos', { pasta: atual, mudados, deVoce });
-        });
+        pararVigia = vigiar(atual, (mudados) => op.emitir('arquivos', { pasta: atual, mudados }));
         op.emitir('arquivos', { pasta: atual, mudados: [], trocou: true });
         return atual;
     }
-    // O /dir troca a pasta pelo terminal, sem passar por aqui: sem esta volta
-    // a IDE continuaria vigiando o projeto anterior.
-    /* E só depois que a IDE foi aberta de verdade: quem abriu só o chat do
-       /rc não precisa de ninguém vigiando o ~/primocode inteiro — no Linux
-       o fs.watch recursivo custa um aviso do sistema por pasta. */
+    /* O /dir e os projetos da barra lateral trocam a pasta sem passar por
+       aqui: sem esta ronda o painel vigiaria o projeto anterior. E só depois
+       que o painel foi aberto de verdade — no Linux o fs.watch recursivo custa
+       um aviso do sistema por pasta, e quem só conversa não precisa disso. */
     let usada = false;
     const ronda = setInterval(() => { if (usada) conferirPasta(); }, 2000);
     if (ronda.unref) ronda.unref();
@@ -279,48 +250,31 @@ function montar(op) {
         res.end(JSON.stringify(corpo));
     }
 
-    function lerCorpo(req) {
-        return new Promise((ok) => {
-            let corpo = '';
-            let grande = false;
-            req.on('data', (c) => { corpo += c; if (corpo.length > MAX_EDITOR * 2) { grande = true; req.destroy(); } });
-            req.on('end', () => { try { ok(grande ? null : JSON.parse(corpo)); } catch { ok(null); } });
-        });
-    }
-
-    /* Devolve true se a rota era da IDE. A chave já foi conferida pelo
-       app.js antes de chegar aqui — só as rotas com /api/ passam por ela, e
-       por isso a prévia também mora debaixo de /api/. */
+    /* Devolve true se a rota era do painel. A chave já foi conferida pelo
+       app.js antes de chegar aqui — por isso a prévia também mora em /api/. */
     async function atender(req, res, url) {
         const rota = url.pathname;
-        if (!rota.startsWith('/api/ide/')) return false;
+        const ehArquivos = rota.startsWith('/api/arquivos/');
+        const m = rota.match(/^\/api\/previa\/[0-9a-f]+\/?(.*)$/);
+        if (!ehArquivos && !m) return false;
         usada = true;
         const raiz = conferirPasta();
         if (!raiz || !fs.existsSync(raiz)) { json(res, 404, { ok: false, error: 'sem pasta de projeto' }); return true; }
 
-        if (rota === '/api/ide/arvore') {
+        if (rota === '/api/arquivos/arvore') {
             const a = arvore(raiz);
             json(res, 200, { ok: true, pasta: raiz, nome: path.basename(raiz), itens: a.itens,
                 cortada: a.cortada, entrada: entradaDaPrevia(raiz) });
             return true;
         }
-        if (rota === '/api/ide/arquivo') {
+        if (rota === '/api/arquivos/ler') {
             const r = ler(raiz, url.searchParams.get('p') || '');
             json(res, r.status, r.corpo);
             return true;
         }
-        if (rota === '/api/ide/salvar' && req.method === 'POST') {
-            const dados = await lerCorpo(req);
-            if (!dados) { json(res, 400, { ok: false, error: 'pedido ilegível ou maior que 1 MB' }); return true; }
-            const r = salvar(raiz, dados);
-            if (r.corpo.ok) salvosAgora.set(r.corpo.caminho, Date.now());
-            json(res, r.status, r.corpo);
-            return true;
-        }
-        /* /api/ide/previa/<chave>/<caminho>: a chave vai no CAMINHO, não na
+        /* /api/previa/<chave>/<caminho>: a chave vai no CAMINHO, não na
            query, porque a página da prévia pede style.css e script.js por
            endereço relativo — e o relativo herda o caminho, não a query. */
-        const m = rota.match(/^\/api\/ide\/previa\/[0-9a-f]+\/?(.*)$/);
         if (m) { servirPrevia(raiz, m[1], res); return true; }
 
         json(res, 404, { ok: false, error: 'rota desconhecida' });
@@ -334,4 +288,4 @@ function montar(op) {
     };
 }
 
-module.exports = { montar, dentro, arvore, ler, salvar, vigiar, ehBinario, entradaDaPrevia, MAX_EDITOR };
+module.exports = { montar, dentro, arvore, ler, vigiar, ehBinario, entradaDaPrevia, MAX_LEITURA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.7",
+  "version": "9.8.0-beta.9",
   "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": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/kits.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/ide.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/app-janela.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js"
   },
   "engines": {
     "node": ">=18.17.0"
@@ -30,7 +30,6 @@
     "app/",
     "studio/",
     "skills/",
-    "kits/",
     "voz/",
     "README.md",
     "comandos/",

package/skills/design-de-verdade/SKILL.md

@@ -7,6 +7,8 @@ autor: adaptado de "frontend-design" (Anthropic, anthropics/skills, Apache-2.0
 Trabalhe como o diretor de arte de um estúdio conhecido por dar a cada cliente uma identidade que
 ninguém confunde. O cliente já recusou propostas com cara de modelo pronto.
 
+**Não existe modelo.** Toda página começa do zero, e nenhuma sai com a estrutura da anterior.
+
 **Comece pelo assunto.** O ramo, os materiais e o vocabulário do negócio são de onde vem a escolha
 visual. Um brinquedo para meninas de 8 anos e um painel de analista financeiro não se parecem em nada.
 Use o conteúdo real do pedido em tudo, e não texto genérico.

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

@@ -1,7 +1,7 @@
 ---
 nome: Motion de primeira
 descricao: como um vídeo criado do zero deixa de parecer feito por máquina
-quando: vídeo, video, motion, animação, animacao, anúncio, anuncio, reels, teaser, abertura, comercial, propaganda, estúdio, estudio
+quando: vídeo, video, motion graphics, vídeo animado, video animado, anúncio, anuncio, reels, teaser, vinheta, comercial, propaganda, estúdio, estudio
 autor: PrimoCode
 ---
 Não existe template. Cada propriedade deste vídeo é uma decisão sua, e a