primocode 10.17.0 → 10.19.0

package/lib/limite.js

@@ -0,0 +1,99 @@
+/**
+ * limite.js — a parte "limite" do /usage: quanto você já usou hoje e quanto um pedido grande deve gastar.
+ *
+ *   guardarSessao(id, tokens)    marca quanto ESTA conversa já gastou (idempotente: guarda o total, não soma)
+ *   usoDeHoje()                  → { tokens }            (todas as conversas de hoje, as de antes também)
+ *   limiteConhecido()            → número | null         (só o que a pessoa informou: /usage limite 100000)
+ *   estimar({ texto, ... })      → tokens que o pedido deve gastar
+ *   linhaDoPedido(...)           → "isso deve gastar uns 7% do seu plano de hoje" | aviso honesto | null
+ *   zeraEm(agora)                → "à meia-noite (daqui a 5h)"
+ *
+ * O PrimoCode NÃO tem como perguntar ao servidor qual é o limite do seu plano: o cliente só conta o que ele mesmo
+ * mandou e recebeu. Então a conta de "hoje" é nossa (um arquivo, ~/.primocode/uso.json) e o limite só entra se a
+ * pessoa disser qual é. Sem ele, a linha diz isso com todas as letras, em vez de inventar uma porcentagem.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const arquivo = () => process.env.PRIMOCODE_USO || path.join(os.homedir(), '.primocode', 'uso.json');
+const BASE_PEDIDO = 4000;          // o que um pedido do agente já custa antes de a pessoa digitar (ferramentas + sistema)
+const GRANDE = 300;                // caracteres a partir dos quais o pedido conta como grande
+
+const diaDe = (agora) => `${agora.getFullYear()}-${String(agora.getMonth() + 1).padStart(2, '0')}-${String(agora.getDate()).padStart(2, '0')}`;
+
+function ler(agora = new Date()) {
+    let j = {};
+    try { j = JSON.parse(fs.readFileSync(arquivo(), 'utf8')); } catch { j = {}; }
+    const hoje = j.dia === diaDe(agora);
+    return { limite: Number(j.limite) > 0 ? Number(j.limite) : null, dia: diaDe(agora), sessoes: hoje && j.sessoes ? j.sessoes : {} };
+}
+
+function gravar(d) {
+    try {
+        fs.mkdirSync(path.dirname(arquivo()), { recursive: true });
+        fs.writeFileSync(arquivo(), JSON.stringify({ dia: d.dia, limite: d.limite || undefined, sessoes: d.sessoes }, null, 2));
+    } catch { /* contar nunca derruba um pedido */ }
+}
+
+function guardarSessao(id, tokens, agora = new Date()) {
+    const d = ler(agora);
+    d.sessoes[id] = Math.max(0, Math.round(tokens));
+    gravar(d);
+}
+
+function usoDeHoje(agora = new Date()) {
+    return { tokens: Object.values(ler(agora).sessoes).reduce((s, n) => s + n, 0) };
+}
+
+const limiteConhecido = () => ler().limite;
+
+function definirLimite(tokens, agora = new Date()) {
+    const n = Math.round(Number(tokens));
+    if (!(n > 0)) return false;
+    const d = ler(agora); d.limite = n; gravar(d);
+    return true;
+}
+
+function pedidoGrande(texto, anexosChars = 0) {
+    return String(texto || '').length >= GRANDE || anexosChars > 0;
+}
+
+/** `mediaPorPedido`: o que os pedidos de hoje já custaram, em média; sem ela, o custo base. */
+function estimar({ texto, anexosChars = 0, mediaPorPedido = 0 }) {
+    return Math.max(mediaPorPedido, BASE_PEDIDO) + Math.ceil((String(texto || '').length + anexosChars) / 4);
+}
+
+const mil = (n) => (n >= 1000 ? `${Math.round(n / 1000)} mil` : String(n));
+
+/** `limite` null = não dá pra saber: diz isso, sem número inventado. */
+function linhaDoPedido({ tokens, limite, usadoHoje = 0 }) {
+    if (!limite) {
+        return `Pedido grande: deve gastar uns ${mil(tokens)} tokens. Não consigo ver o limite do seu plano daqui, então não sei dizer quantos % isso é. `
+            + 'Se você sabe o limite, ensine: /usage limite <tokens por dia>.';
+    }
+    const pct = Math.max(1, Math.round((tokens / limite) * 100));
+    const ja = Math.round((usadoHoje / limite) * 100);
+    return `Isso deve gastar uns ${pct}% do seu plano de hoje${usadoHoje ? ` (você já usou ${ja}%)` : ''}.`;
+}
+
+function zeraEm(agora = new Date()) {
+    const meia = new Date(agora); meia.setHours(24, 0, 0, 0);
+    const min = Math.max(1, Math.round((meia - agora) / 60000));
+    const quanto = min >= 60 ? `${Math.floor(min / 60)}h${min % 60 ? String(min % 60).padStart(2, '0') : ''}` : `${min} min`;
+    return `à meia-noite (daqui a ${quanto})`;
+}
+
+/** As linhas da parte "limite" do /usage. */
+function resumoDeHoje({ tokens, limite, agora = new Date() }) {
+    const L = [`Hoje, em todas as conversas: ${Number(tokens).toLocaleString('pt-BR')} tokens.`];
+    if (limite) L.push(`Isso é ${Math.round((tokens / limite) * 100)}% do limite que você informou (${limite.toLocaleString('pt-BR')} por dia).`);
+    else L.push('O limite do seu plano o servidor não mostra pro PrimoCode, então não sei dizer quantos % isso é. Se você sabe, ensine: /usage limite <tokens por dia>.');
+    L.push(`A conta de hoje zera ${zeraEm(agora)}. ${limite ? '' : 'Quando o seu plano zera de verdade eu não consigo ver.'}`.trim());
+    return L;
+}
+
+module.exports = { guardarSessao, usoDeHoje, limiteConhecido, definirLimite, pedidoGrande, estimar, linhaDoPedido, zeraEm, resumoDeHoje, BASE_PEDIDO, GRANDE };

package/lib/linha-do-tempo.js

@@ -0,0 +1,130 @@
+/**
+ * linha-do-tempo.js — a história do projeto numa página, com o ponto pra onde voltar.
+ *
+ * O `/desfazer lista` mostra os pedidos no terminal, e quem nunca programou
+ * não lê isso. Aqui os mesmos pontos (lib/checkpoint.js) viram uma página
+ * HTML: um cartão por pedido, o que ele mudou, o selo "funcionava" que o
+ * /conferir deixou, e o comando pronto pra copiar e voltar até ali.
+ *
+ * `montarHtml` é pura (sem disco, sem relógio): recebe os pontos e a hora de
+ * agora. `gravar` é quem pega a lista de verdade e escreve o arquivo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const checkpoint = require('./checkpoint');
+
+const VERBO = { criado: 'criou', mudou: 'mudou', apagado: 'apagou' };
+
+/** O pedido é texto da pessoa: nunca entra no HTML sem escapar. */
+function esc(s) {
+    return String(s === undefined || s === null ? '' : s)
+        .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+
+const dois = (n) => String(n).padStart(2, '0');
+const hora = (d) => `${dois(d.getHours())}:${dois(d.getMinutes())}`;
+const diaMes = (d) => `${dois(d.getDate())}/${dois(d.getMonth() + 1)}`;
+const meiaNoite = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+
+/** "hoje 14:02", "ontem 21:10", senão "24/10 14:02". */
+function horaHumana(quando, agora) {
+    const d = new Date(quando);
+    if (isNaN(d.getTime())) return '';
+    const hoje = meiaNoite(agora instanceof Date ? agora : new Date(agora || Date.now()));
+    const dias = Math.round((hoje - meiaNoite(d)) / 86400000);
+    if (dias === 0) return `hoje ${hora(d)}`;
+    if (dias === 1) return `ontem ${hora(d)}`;
+    return `${diaMes(d)} ${hora(d)}`;
+}
+
+/** Caminho relativo à pasta do projeto (o que a pessoa reconhece). */
+function relativo(caminho, projectDir) {
+    if (!projectDir) return caminho;
+    const r = path.relative(projectDir, caminho);
+    return r && !r.startsWith('..') && !path.isAbsolute(r) ? r : caminho;
+}
+
+const CSS = `
+:root{--fundo:#faf7f2;--cartao:#fff;--tinta:#1d1b18;--suave:#6f6a62;--linha:#ddd6ca;--acento:#ff5a1f;--acento-fundo:#fff0e8;--codigo:#f1ece3}
+@media (prefers-color-scheme:dark){:root{--fundo:#161412;--cartao:#201d1a;--tinta:#f1ece3;--suave:#a39c90;--linha:#3a3530;--acento:#ff7a45;--acento-fundo:#2e1d14;--codigo:#2a2622}}
+*{box-sizing:border-box}
+body{margin:0;background:var(--fundo);color:var(--tinta);font:16px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif}
+main{max-width:640px;margin:0 auto;padding:32px 16px 64px}
+h1{font-size:1.6rem;line-height:1.2;margin:0 0 4px;overflow-wrap:anywhere}
+.sub{color:var(--suave);margin:0 0 28px}
+ol{list-style:none;margin:0;padding:0 0 0 22px;border-left:2px solid var(--linha)}
+li{position:relative;margin:0 0 18px}
+li::before{content:"";position:absolute;left:-29px;top:20px;width:12px;height:12px;border-radius:50%;background:var(--fundo);border:2px solid var(--linha)}
+li.ok::before{background:var(--acento);border-color:var(--acento)}
+.cartao{background:var(--cartao);border:1px solid var(--linha);border-radius:10px;padding:14px 16px}
+li.ok .cartao{border-color:var(--acento);background:var(--acento-fundo)}
+.quando{font-size:.85rem;color:var(--suave);margin:0}
+.pedido{font-weight:600;margin:4px 0 8px;overflow-wrap:anywhere}
+.selo{display:inline-block;color:var(--acento);font-weight:600;font-size:.9rem;margin:0 0 8px}
+.selo small{color:var(--suave);font-weight:400}
+ul.arquivos{margin:0 0 4px;padding:0;list-style:none;font-size:.9rem}
+ul.arquivos li{margin:2px 0;padding:0;overflow-wrap:anywhere}
+ul.arquivos li::before{display:none}
+.acao{color:var(--suave);display:inline-block;min-width:3.8em}
+code{font:.85rem ui-monospace,SFMono-Regular,Menlo,monospace}
+.volta{margin-top:10px;font-size:.85rem;color:var(--suave)}
+.volta pre{margin:4px 0 0;padding:8px 10px;background:var(--codigo);border-radius:6px;overflow-x:auto;user-select:all}
+.vazio{background:var(--cartao);border:1px dashed var(--linha);border-radius:10px;padding:20px;color:var(--suave)}
+`;
+
+function cartao(cp, i, cps, projectDir, agora) {
+    const mudou = cp.mudou || [];
+    const arquivos = mudou.length
+        ? `<ul class="arquivos">${mudou.map((m) => `<li><span class="acao">${esc(VERBO[m.acao] || m.acao)}</span> <code>${esc(relativo(m.caminho, projectDir))}</code></li>`).join('')}</ul>`
+        : '';
+    const selo = cp.funcionava
+        ? `<p class="selo">✓ funcionava${cp.funcionava_como ? ` <small>· conferido com ${esc(cp.funcionava_como)}</small>` : ''}</p>` : '';
+    const ultimoOk = cps.findIndex((x) => x.funcionava) === i && cp.funcionava;
+    let volta = '';
+    if (i > 0) {
+        volta = `<div class="volta">Pra voltar até aqui, copie:<pre><code>/undo ${i}</code></pre>`
+            + (ultimoOk ? `ou, direto pro último que funcionava:<pre><code>/restore</code></pre>` : '') + '</div>';
+    }
+    return `<li class="${cp.funcionava ? 'ok' : ''}"><div class="cartao">`
+        + `<p class="quando">${esc(horaHumana(cp.quando, agora))}</p>`
+        + `<p class="pedido">${esc(cp.pedido || '(sem texto)')}</p>${selo}${arquivos}${volta}</div></li>`;
+}
+
+/** A página inteira, a partir da lista do checkpoint (mais novo primeiro). */
+function montarHtml(cps, { projeto, agora, projectDir } = {}) {
+    cps = cps || [];
+    const nome = projeto || (projectDir ? path.basename(path.resolve(projectDir)) : 'projeto');
+    const corpo = cps.length
+        ? `<ol>${cps.map((cp, i) => cartao(cp, i, cps, projectDir, agora)).join('')}</ol>`
+        : '<div class="vazio">Ainda não tem história: o primeiro pedido que mexer nos arquivos cria o primeiro ponto.</div>';
+    return `<!doctype html>
+<html lang="pt-BR"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>A história de ${esc(nome)}</title>
+<style>${CSS}</style></head>
+<body><main>
+<h1>A história de ${esc(nome)}</h1>
+<p class="sub">Do pedido mais novo pro mais velho. Copie o comando e cole no PrimoCode pra voltar.</p>
+${corpo}
+</main></body></html>
+`;
+}
+
+/** Grava em ~/.primocode/linha-do-tempo/<pasta>.html e devolve o caminho. */
+function gravar(projectDir, { home, agora } = {}) {
+    const abs = path.resolve(projectDir);
+    const nome = path.basename(abs) || 'raiz';
+    const seguro = nome.replace(/[^\w.-]+/g, '-').slice(0, 40) || 'raiz';
+    const dir = path.join(home || os.homedir(), '.primocode', 'linha-do-tempo');
+    fs.mkdirSync(dir, { recursive: true });
+    const arquivo = path.join(dir, `${seguro}.html`);
+    fs.writeFileSync(arquivo, montarHtml(checkpoint.lista(abs), { projeto: nome, agora: agora || new Date(), projectDir: abs }));
+    return arquivo;
+}
+
+module.exports = { montarHtml, gravar, horaHumana };

package/lib/local/cerebro.json

@@ -1,6 +1,6 @@
 {
- "origem": "primocode-server 8.20.0 131e585",
- "SYSTEM_NUCLEO": "Você é o PrimoCode, agente de engenharia da ConectaPrimoAI.\n\nCONVERSA OU TRABALHO: cumprimento, agradecimento, pergunta sobre você ou papo\n(\"oi\", \"o que você faz?\") → responda em texto, 1 ou 2 frases, sem tool nenhuma,\ne não invente tarefa que ninguém pediu. Pedido de criar, alterar, ler, rodar ou\nconsertar → EXECUTE, até o fim, sem conversar no meio.\n\nREGRAS ABSOLUTAS (executando):\n1. NUNCA escreva código na resposta. Código vai SEMPRE dentro de uma tool.\n2. NUNCA pergunte ao usuário. Decida e execute.\n3. NUNCA invente ferramenta, serviço, porta ou API: as suas são EXATAMENTE as\n   desta lista. E nunca diga que algo \"não está rodando\" para se esquivar — o\n   que precisa subir, sobe sozinho quando você chama a tool. Prometer o que\n   você não tem, ou culpar um serviço, é o pior erro possível.\n4. Caminhos RELATIVOS (\"index.html\", \"src/game.js\"). Você já está na pasta do\n   projeto: nunca caminho absoluto, nunca \"../\".\n5. Termine SEMPRE com finish(\"frase curta do que foi feito\").\n6. Resposta em texto: no máximo 1 frase, sem markdown.\n7. NUNCA repita uma chamada que já fez. Reformular a mesma busca traz as mesmas\n   fontes; spec e manual são FIXOS — leu uma vez, está lido. Pesquisou e leu a\n   spec? O passo seguinte é CRIAR com o que já tem.\n\nESCOLHENDO A TOOL: arquivo novo → write_file; mudar parte → edit_file (nunca\nreescreva o arquivo inteiro para trocar poucas linhas); várias mudanças no mesmo\narquivo → multi_edit, numa chamada; não sabe onde está → grep (conteúdo) ou glob\n(nome), nunca list_dir (o mapa já está aqui); servidor de pé → run_in_new_terminal.\n\nANTES DE EDITAR, LEIA SÓ O ARQUIVO QUE VAI MUDAR (edit_file exige o texto\nliteral), inteiro e uma vez. Nada de ler outros \"para entender\".\n\nQUANDO FALHA: leia o erro e conserte. Se edit_file disser \"trecho não\nencontrado\", ele devolve \"trechosParecidos\" com as linhas reais — copie de lá.\nNUNCA chame finish dizendo que fez algo que falhou: \"não consegui alterar X\nporque Y\" é melhor que um \"pronto!\" falso.\n\nPLANO: tarefa de 3+ passos começa com write_todos e vai atualizando o status (só\nUMA \"in_progress\" por vez). Tarefa curta não precisa.\n\nCOMO VOCÊ FALA ENQUANTO TRABALHA: antes de uma tool que muda o rumo (conserto,\nconversão, desvio), UMA frase em primeira pessoa com o quê e o porquê (\"o vídeo\nveio em .avi, vou converter para mp4\"); resolvido, \"feito, continuando\". Passo\nóbvio não precisa. NUNCA cite limite, cota, token, modelo, provedor, tentativa\nou erro interno: quem lê vê o trabalho, não o encanamento. Contornou uma\nfalha? Conte o contorno.\n\nMEMÓRIA: você recebe memory-geral.md (o usuário) e o memory.md do projeto.\nRespeite as preferências e decisões que estão lá, e não recomece do zero um\nprojeto que já tem arquivos — veja o mapa antes de escrever. O memory.md do projeto se\ngrava sozinho. Já o memory-geral.md só guarda o que você mandar com\nremember_general: nome, preferência que vale em qualquer projeto, decisão de\nlongo prazo. Sem essa chamada, nada disso sobrevive para a próxima vez.\n\nPROCESSO: ache o alvo (mapa ou grep) → leia só ele → faça → confira → finish.\nCriar do zero: escreva direto, sem ler nada.",
+ "origem": "primocode-server 8.20.0 46ada83",
+ "SYSTEM_NUCLEO": "Você é o PrimoCode, agente de engenharia da ConectaPrimoAI.\n\nCONVERSA OU TRABALHO: cumprimento, agradecimento, pergunta sobre você ou papo\n(\"oi\", \"o que você faz?\") → responda em texto, 1 ou 2 frases, sem tool nenhuma,\ne não invente tarefa que ninguém pediu. Pedido de criar, alterar, ler, rodar ou\nconsertar → EXECUTE, até o fim, sem conversar no meio.\n\nREGRAS ABSOLUTAS (executando):\n1. NUNCA escreva código na resposta. Código vai SEMPRE dentro de uma tool.\n2. NUNCA pergunte ao usuário. Decida e execute.\n3. NUNCA invente ferramenta, serviço, porta ou API: as suas são EXATAMENTE as\n   desta lista. E nunca diga que algo \"não está rodando\" para se esquivar — o\n   que precisa subir, sobe sozinho quando você chama a tool. Prometer o que\n   você não tem, ou culpar um serviço, é o pior erro possível.\n4. Caminhos RELATIVOS (\"index.html\", \"src/game.js\"). Você já está na pasta do\n   projeto: nunca caminho absoluto, nunca \"../\".\n5. Termine SEMPRE com finish(\"frase curta do que foi feito\").\n6. Resposta em texto: no máximo 1 frase, sem markdown.\n7. NUNCA repita uma chamada que já fez. Reformular a mesma busca traz as mesmas\n   fontes; spec e manual são FIXOS — leu uma vez, está lido. Pesquisou e leu a\n   spec? O passo seguinte é CRIAR com o que já tem.\n\nESCOLHENDO A TOOL: arquivo novo → write_file; mudar parte → edit_file (nunca\nreescreva o arquivo inteiro para trocar poucas linhas); várias mudanças no mesmo\narquivo → multi_edit, numa chamada; não sabe onde está → grep (conteúdo) ou glob\n(nome), nunca list_dir (o mapa já está aqui); servidor de pé → run_background.\n\nANTES DE EDITAR, LEIA SÓ O ARQUIVO QUE VAI MUDAR (edit_file exige o texto\nliteral), inteiro e uma vez. Nada de ler outros \"para entender\".\n\nQUANDO FALHA: leia o erro e conserte. Se edit_file disser \"trecho não\nencontrado\", ele devolve \"trechosParecidos\" com as linhas reais — copie de lá.\nNUNCA chame finish dizendo que fez algo que falhou: \"não consegui alterar X\nporque Y\" é melhor que um \"pronto!\" falso.\n\nPLANO: tarefa de 3+ passos começa com write_todos e vai atualizando o status (só\nUMA \"in_progress\" por vez). Tarefa curta não precisa.\n\nCOMO VOCÊ FALA ENQUANTO TRABALHA: antes de uma tool que muda o rumo (conserto,\nconversão, desvio), UMA frase em primeira pessoa com o quê e o porquê (\"o vídeo\nveio em .avi, vou converter para mp4\"); resolvido, \"feito, continuando\". Passo\nóbvio não precisa. NUNCA cite limite, cota, token, modelo, provedor, tentativa\nou erro interno: quem lê vê o trabalho, não o encanamento. Contornou uma\nfalha? Conte o contorno.\n\nMEMÓRIA: você recebe memory-geral.md (o usuário) e o memory.md do projeto.\nRespeite as preferências e decisões que estão lá, e não recomece do zero um\nprojeto que já tem arquivos — veja o mapa antes de escrever. O memory.md do projeto se\ngrava sozinho. Já o memory-geral.md só guarda o que você mandar com\nremember_general: nome, preferência que vale em qualquer projeto, decisão de\nlongo prazo. Sem essa chamada, nada disso sobrevive para a próxima vez.\n\nPROCESSO: ache o alvo (mapa ou grep) → leia só ele → faça → confira → finish.\nCriar do zero: escreva direto, sem ler nada.",
  "SECOES": {
   "pesquisa": "PEDIDO QUE DEPENDE DE FATO DO MUNDO — PESQUISE PRIMEIRO:\nSe o que o usuário pediu envolve algo real (uma empresa, um produto, uma\npessoa, um mercado, um número, um acontecimento), chame pesquisar_referencia\nANTES de criar qualquer coisa, em qualquer esforço. \"Pesquise sobre a empresa X\ne faça slides\" é UM pedido só: pesquisa e depois cria, sem parar para perguntar\ne sem entregar o deck com dado inventado.\n\nUm deck bonito cheio de número inventado é pior que nenhum deck — o usuário\nleva aquilo para uma reunião. Se depois da pesquisa faltar um dado, escreva na\npeça o que você sabe e deixe o buraco explícito (\"faturamento: não divulgado\"),\nnunca um número plausível de sua cabeça.",
   "estudio": "O ESTÚDIO — VÍDEO, MOTION, SLIDES E ARTE, FEITOS AQUI:\nCada peça é uma PASTA no computador do usuário, e o arquivo final sai pelo\nRemotion (.mp4 no vídeo, .pdf em slides e arte). Nada de link para abrir num\nsite: no fim, o arquivo abre sozinho para o usuário.\n\nFLUXO (vídeo, motion, slides ou arte feitos do zero):\n1. estudio_projeto acao:\"criar\" (titulo, pedido, formato: video | slides | arte).\n2. Empresa ou marca de verdade → estudio_site ANTES, e use as cores, a fonte\n   e a logo que ele devolve em roteiro.marca.\n3. estudio_plano com ROTEIRO: 6 a 12 partes, cada uma com o tipo certo\n   (abertura, numero, lista, passos, contraste, citacao, imagem, grafico,\n   titulo, cta) e a \"fala\" — a frase dita, que não repete a tela. O PrimoCode\n   faz o layout, a voz com entonação, os ícones, a música e os sons. NÃO\n   escreva cenas nem posições à mão.\n4. estudio_render. Para ajustar, mande o roteiro de novo com a mudança.\n\nGRAVAÇÃO DO USUÁRIO FALANDO (\"edita meu vídeo\", \"faz um reels disso\", \"coloca\nlegenda e efeitos\", um .mp4/.mov dele): a edição completa é do editor_pro (o\nmotor do EDIT IA PRO). acao:\"cortar\" com o video → leia a fala que volta (com os\ntempos) → acao:\"montar\" com a pasta e o plano (gancho, pecas, broll) → entregue\n<pasta>/final.mp4 só com o portão PASSOU. Atalho: acao:\"editar\" faz tudo com o\nplano automático. Operações soltas na gravação (só cortar um trecho, juntar,\nexportar) seguem no estudio_video. NUNCA escreva .mp4/.mp3 com write_file e\nnunca monte vídeo com ffmpeg na mão.\n\nO ROTEIRO BOM: a primeira parte prende (abertura ou contraste), o miolo prova\n(numero, grafico, lista, imagem) e a última pede ação (cta). Varie os tipos —\ntrês \"titulo\" seguidos parecem slide parado. Título que diz algo (\"Receita\ntriplicou em 18 meses\"), não rótulo (\"Resultados\"). Número de verdade ou\nnenhum. A fala não repete a tela: a tela dá o título, a voz dá o argumento.\n\nSE O USUÁRIO CITAR UM APP (Canva, PowerPoint, CapCut, Premiere…): faça a peça\ncom as ferramentas do Estúdio e avise em uma linha. Se ele insistir no app,\nprocure um MCP dele (mcp_procurar) antes de abrir com o mouse.\n\nDocumento, planilha e PDF não são do Estúdio: faça o arquivo (.docx, .xlsx,\n.pdf) com código, na pasta do projeto.",
@@ -258,6 +258,64 @@
     }
    }
   },
+  {
+   "type": "function",
+   "function": {
+    "name": "run_background",
+    "description": "Roda em segundo plano um comando que fica de pe (servidor de dev, watch) e devolve um id. Nao trava a sessao. Leia a saida com background_output para conferir que subiu ou ver o erro; pare com stop_background.",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "command": {
+       "type": "string"
+      }
+     },
+     "required": [
+      "command"
+     ]
+    }
+   }
+  },
+  {
+   "type": "function",
+   "function": {
+    "name": "background_output",
+    "description": "Le a saida nova de uma tarefa do run_background (so o que chegou desde a ultima leitura). Diz se ainda roda e o codigo de saida.",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "id": {
+       "type": "string"
+      },
+      "desde": {
+       "type": "number",
+       "description": "Offset da leitura anterior (campo \"ate\"); omita para seguir de onde parou"
+      }
+     },
+     "required": [
+      "id"
+     ]
+    }
+   }
+  },
+  {
+   "type": "function",
+   "function": {
+    "name": "stop_background",
+    "description": "Para uma tarefa do run_background (e os processos filhos dela).",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "id": {
+       "type": "string"
+      }
+     },
+     "required": [
+      "id"
+     ]
+    }
+   }
+  },
   {
    "type": "function",
    "function": {
@@ -1877,6 +1935,64 @@
     }
    }
   },
+  {
+   "type": "function",
+   "function": {
+    "name": "run_background",
+    "description": "Roda em segundo plano um comando que fica de pe (servidor de dev, watch) e devolve um id. Nao trava a sessao. Leia a saida com background_output para conferir que subiu ou ver o erro; pare com stop_background.",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "command": {
+       "type": "string"
+      }
+     },
+     "required": [
+      "command"
+     ]
+    }
+   }
+  },
+  {
+   "type": "function",
+   "function": {
+    "name": "background_output",
+    "description": "Le a saida nova de uma tarefa do run_background (so o que chegou desde a ultima leitura). Diz se ainda roda e o codigo de saida.",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "id": {
+       "type": "string"
+      },
+      "desde": {
+       "type": "number",
+       "description": "Offset da leitura anterior (campo \"ate\"); omita para seguir de onde parou"
+      }
+     },
+     "required": [
+      "id"
+     ]
+    }
+   }
+  },
+  {
+   "type": "function",
+   "function": {
+    "name": "stop_background",
+    "description": "Para uma tarefa do run_background (e os processos filhos dela).",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "id": {
+       "type": "string"
+      }
+     },
+     "required": [
+      "id"
+     ]
+    }
+   }
+  },
   {
    "type": "function",
    "function": {

package/lib/local/entrada.js

@@ -165,7 +165,7 @@ const GRUPOS = [
     },
     {
         nome: 'terminal',
-        tools: ['run_in_new_terminal'],
+        tools: ['run_in_new_terminal', 'run_background', 'background_output', 'stop_background'],
         gatilho: /\b(servidor|dev|watch|npm run|yarn|vite|next|rodar? em segundo plano|localhost|porta \d+)\b/i,
     },
     {

package/lib/mapa.js

@@ -0,0 +1,94 @@
+/**
+ * mapa.js — o /mapa: o que tem no projeto, em português, e o que está faltando.
+ *
+ *   montar(projectDir) → { entrada, grupos: { nome: [rel] }, usa: { rel: [rel] }, faltando: [{ arquivo, pedido_por }] }
+ *   texto(m, nome)     → as linhas pro terminal                                                     (puro)
+ *
+ * O dia seguinte de quem fez o primeiro app com IA: volta ao projeto e não sabe o que é cada arquivo nem onde mexer
+ * ("vibe code is legacy code", blog.stephenturner.us [VERIFICAR]). Sem modelo: os nomes, a extensão e o que cada
+ * arquivo puxa (<script src>, <link href>, <img src>, import e require relativos). O que é puxado e não existe vira
+ * "faltando" — o caso da lista de compras de 23/10, cujo index.html pedia um style.css e um script.js que não nasceram.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const LIMITE = 2000;   // projeto maior que isso: o mapa mostra, mas não acusa "faltando" (a lista ficou pela metade)
+const PULAR = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache', '.venv', 'venv', '__pycache__']);
+const GRUPOS = [
+    ['páginas', /\.html?$/i], ['estilo', /\.(css|scss|sass)$/i], ['lógica', /\.(m?[jt]sx?|cjs|py|rb|go|rs|php)$/i],
+    ['dados', /\.(json|csv|ya?ml|toml|sql|db)$/i], ['imagens e mídia', /\.(png|jpe?g|gif|svg|webp|ico|mp4|mp3|wav|woff2?)$/i], ['textos', /\.(md|txt)$/i],
+];
+
+function listar(dir, base = dir, out = []) {
+    let itens = [];
+    try { itens = fs.readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+    for (const it of itens) {
+        if (it.name.startsWith('.') || PULAR.has(it.name)) continue;
+        const abs = path.join(dir, it.name);
+        if (it.isDirectory()) listar(abs, base, out);
+        else out.push(path.relative(base, abs));
+        if (out.length >= LIMITE) break;
+    }
+    return out;
+}
+
+/** O que um arquivo puxa, como caminho relativo à pasta do projeto (só o local: http, //, data: e # ficam de fora). */
+function referencias(rel, texto) {
+    const achados = [];
+    const pega = (re) => { for (const m of texto.matchAll(re)) achados.push(m[1]); };
+    if (/\.html?$/i.test(rel)) { pega(/<script[^>]+src=["']([^"']+)["']/gi); pega(/<link[^>]+href=["']([^"']+)["']/gi); pega(/<img[^>]+src=["']([^"']+)["']/gi); }
+    if (/\.(m?[jt]sx?|cjs)$/i.test(rel)) { pega(/\bimport\s[^'"]*?from\s*["'](\.[^"']+)["']/g); pega(/\brequire\(\s*["'](\.[^"']+)["']\s*\)/g); pega(/\bimport\s*["'](\.[^"']+)["']/g); }
+    if (/\.css$/i.test(rel)) pega(/@import\s+(?:url\()?["']([^"']+)["']/g);
+    return achados
+        .filter((r) => r && !/^(https?:)?\/\//i.test(r) && !/^(data|mailto|tel):|^#/i.test(r))
+        // "/style.css" é a partir da raiz do site, não da pasta do arquivo (o Vite também: "/src/main.jsx")
+        .map((r) => { const s = r.split(/[?#]/)[0]; return path.normalize(s.startsWith('/') ? s.slice(1) : path.join(path.dirname(rel), s)).replace(/^\.\//, ''); });
+}
+
+function montar(projectDir) {
+    const arquivos = listar(projectDir);
+    const existe = new Set(arquivos);
+    const truncado = arquivos.length >= LIMITE;
+    const grupos = {}, usa = {}, faltando = [];
+    for (const rel of arquivos) {
+        const g = (GRUPOS.find(([, re]) => re.test(rel)) || ['outros'])[0];
+        (grupos[g] = grupos[g] || []).push(rel);
+        if (!/\.(html?|m?[jt]sx?|cjs|css)$/i.test(rel)) continue;
+        let texto = '';
+        try { if (fs.statSync(path.join(projectDir, rel)).size < 512 * 1024) texto = fs.readFileSync(path.join(projectDir, rel), 'utf8'); } catch { continue; }
+        const refs = [...new Set(referencias(rel, texto))];
+        if (refs.length) usa[rel] = refs;
+        for (const r of refs) {
+            // import sem extensão (./util → util.js, util/index.js): conta como achado se alguma variante existe
+            const ext = ['.js', '.mjs', '.cjs', '.ts', '.jsx', '.tsx'];
+            const variantes = [r, ...ext.map((e) => r + e), ...ext.map((e) => path.join(r, 'index' + e))];
+            if (!truncado && !variantes.some((v) => existe.has(v))) faltando.push({ arquivo: r, pedido_por: rel });
+        }
+    }
+    const entrada = ['index.html', 'src/index.html', 'public/index.html', 'main.py', 'app.py', 'index.js', 'src/main.js', 'src/index.js'].find((e) => existe.has(e)) || null;
+    return { entrada, grupos, usa, faltando, total: arquivos.length, truncado };
+}
+
+function texto(m, nome = 'o projeto') {
+    if (!m.total) return [`${nome} ainda está vazio: nenhum arquivo.`];
+    const out = [`${nome}: ${m.total} ${m.total === 1 ? 'arquivo' : 'arquivos'}` + (m.entrada ? ` · começa por ${m.entrada}` : '')];
+    for (const [g, lista] of Object.entries(m.grupos)) {
+        const mostra = lista.slice(0, 6).join(', ') + (lista.length > 6 ? ` e mais ${lista.length - 6}` : '');
+        out.push(`  ${g.padEnd(16)} ${mostra}`);
+    }
+    const ligacoes = Object.entries(m.usa).slice(0, 6);
+    if (ligacoes.length) {
+        out.push('  quem usa quem');
+        for (const [de, para] of ligacoes) out.push(`    ${de} → ${para.slice(0, 5).join(', ')}`);
+    }
+    if (m.faltando.length) {
+        out.push(`  ⚠ faltando ${m.faltando.length === 1 ? 'um arquivo' : m.faltando.length + ' arquivos'}:`);
+        for (const f of m.faltando.slice(0, 8)) out.push(`    ${f.arquivo}  (o ${f.pedido_por} pede, e ele não existe)`);
+    }
+    return out;
+}
+
+module.exports = { montar, texto, referencias };

package/lib/mcp.js

@@ -54,28 +54,117 @@ function servidores(pasta = process.cwd()) {
     const out = process.env.PRIMOCODE_SEM_MCP === '1' ? {} : { ...PADRAO };
     for (const arq of [CONFIG, path.join(pasta, '.mcp.json')]) {
         const j = lerJson(arq);
-        for (const [nome, s] of Object.entries((j && j.mcpServers) || {})) if (s && (s.command || s.url)) out[nome] = s;
+        const doProjeto = arq !== CONFIG;
+        for (const [nome, s] of Object.entries((j && j.mcpServers) || {})) {
+            if (s && (s.command || s.url)) out[nome] = doProjeto ? marcarProjeto(s, nome, pasta) : s;
+        }
     }
     return out;
 }
 
+/* ── SERVIDOR QUE VEM DO PROJETO ─────────────────────────────────────────
+ * O .mcp.json de um repo clonado roda comando na máquina de quem abre. Então
+ * servidor do PROJETO (não o do ~/.primocode/mcp.json) só sobe com o sim da
+ * pessoa, mesmo no modo auto — lembrado por projeto + configuração exata
+ * (hash de command+args+env…): mudou o .mcp.json, pergunta de novo. Sem
+ * ninguém para perguntar (headless), não sobe. */
+const APROVADOS = path.join(CASA, 'mcp-aprovados.json');
+let perguntador = null;   // async ({ nome, pasta, def, resumo }) → boolean
+let filaDePerguntas = Promise.resolve();
+
+function marcarProjeto(def, nome, pasta) {
+    const c = { ...def };
+    Object.defineProperty(c, '_projeto', { value: { nome, pasta: path.resolve(pasta) }, enumerable: false });
+    return c;
+}
+
+function hashDoServidor(def) {
+    const d = def || {};
+    const base = JSON.stringify([d.type || '', d.command || '', d.args || [], d.env || {}, d.url || '', d.headers || {}]);
+    return require('crypto').createHash('sha256').update(base).digest('hex');
+}
+
+function usarPerguntador(fn) { perguntador = typeof fn === 'function' ? fn : null; }
+
+function jaAprovado(pasta, def) {
+    const j = lerJson(APROVADOS) || {};
+    return !!(j[path.resolve(pasta)] || {})[hashDoServidor(def)];
+}
+
+function aprovarProjeto(pasta, def, nome = '') {
+    const j = lerJson(APROVADOS) || {};
+    const k = path.resolve(pasta);
+    j[k] = j[k] || {};
+    j[k][hashDoServidor(def)] = nome || true;
+    fs.mkdirSync(CASA, { recursive: true });
+    fs.writeFileSync(APROVADOS, JSON.stringify(j, null, 2), { mode: 0o600 });
+}
+
+function resumoDoServidor(def) {
+    return def.url ? `${def.url}` : [def.command, ...(def.args || [])].join(' ');
+}
+
+/** Lança se o servidor do projeto não foi aprovado (e não há como perguntar). */
+async function autorizarProjeto(def, nomeDado) {
+    const info = def && def._projeto;
+    if (!info) return;
+    const nome = nomeDado || info.nome;
+    if (jaAprovado(info.pasta, def)) return;
+    const recusa = (porque) => {
+        process.stderr.write(`[mcp] servidor "${nome}" do .mcp.json do projeto NÃO foi iniciado: ${porque}\n`);
+        throw new Error(`o servidor MCP "${nome}" vem do .mcp.json deste projeto e não foi aprovado (${porque}). `
+            + 'Rode o PrimoCode neste terminal para aprovar, ou mova o servidor para ~/.primocode/mcp.json.');
+    };
+    if (!perguntador) recusa('sem terminal para pedir o sim');
+    const ok = await (filaDePerguntas = filaDePerguntas.catch(() => {}).then(async () => {
+        if (jaAprovado(info.pasta, def)) return true;
+        const r = await perguntador({ nome, pasta: info.pasta, def, resumo: resumoDoServidor(def) });
+        if (r) aprovarProjeto(info.pasta, def, nome);
+        return !!r;
+    }));
+    if (!ok) recusa('a pessoa não aprovou');
+}
+
+/* Variáveis que o `${VAR}` de um servidor do PROJETO pode ler. O resto vira
+   vazio: um .mcp.json clonado não pode mandar GITHUB_TOKEN para uma URL. Quem
+   quer liberar mais escreve "envPermitidas": ["X"] no ~/.primocode/mcp.json. */
+const ENV_PERMITIDAS = ['HOME', 'USER', 'PATH', 'PWD', 'TMPDIR', 'LANG', 'SHELL'];
+
+function permitidasDoUsuario() {
+    const j = lerJson(CONFIG);
+    return Array.isArray(j && j.envPermitidas) ? j.envPermitidas.map(String) : [];
+}
+
 /** Abre um servidor, faz o aperto de mão e devolve {pedir, fechar}. */
 /* `${VAR}` no argumento vira o valor do env. Sem shell no meio (spawn puro),
    ninguém expandiria — e é assim que o token entra no header do mcp-remote
    sem ficar escrito duas vezes no mcp.json. */
-function expandir(args, env) {
-    return (args || []).map((a) => String(a).replace(/\$\{([A-Z0-9_]+)\}/g, (_, k) => (env[k] != null ? env[k] : '')));
+function expandir(args, env, { projeto = false, permitidas = [], aviso = null } = {}) {
+    const livres = new Set([...ENV_PERMITIDAS, ...permitidas]);
+    return (args || []).map((a) => String(a).replace(/\$\{([A-Z0-9_]+)\}/g, (_, k) => {
+        if (projeto && !livres.has(k)) {
+            (aviso || ((m) => process.stderr.write(`[mcp] ${m}\n`)))(`\${${k}} no .mcp.json do projeto não é permitida e virou vazia`);
+            return '';
+        }
+        return env[k] != null ? env[k] : '';
+    }));
+}
+
+/** O que o `${VAR}` deste servidor pode ver: o do projeto só lê a lista permitida. */
+function opcoesDeExpansao(def) {
+    return def && def._projeto ? { projeto: true, permitidas: [...permitidasDoUsuario(), ...Object.keys(def.env || {})] } : {};
 }
 
 /** Sobe/abre o servidor: `url` → HTTP, senão stdio. Mesma interface: {pedir, fechar}. */
-function conectar(def, opcoes = {}) {
+async function conectar(def, opcoes = {}) {
+    await autorizarProjeto(def, opcoes.nome);
     return def && def.url ? conectarHttp(def, opcoes) : conectarStdio(def, opcoes);
 }
 
 function conectarStdio(def, { tetoMs = 60000 } = {}) {
     return new Promise((resolve, reject) => {
         const env = { ...process.env, ...(def.env || {}) };
-        const p = spawn(def.command, expandir(def.args, env), { env, stdio: ['pipe', 'pipe', 'pipe'] });
+        const p = spawn(def.command, expandir(def.args, env, opcoesDeExpansao(def)), { env, stdio: ['pipe', 'pipe', 'pipe'] });
         let buf = '', id = 0;
         const espera = new Map();
         const relogio = setTimeout(() => { try { p.kill(); } catch {} reject(new Error('o servidor MCP não respondeu')); }, tetoMs);
@@ -154,7 +243,7 @@ function conectarHttp(def, { tetoMs = 60000, nome, buscar = globalThis.fetch } =
         const env = { ...process.env, ...(def.env || {}) };
         // ID token da conta do PrimoCode já logada (o preset primocode-clube usa no lugar de OAuth).
         if (env.PRIMOCODE_ID_TOKEN == null) { try { env.PRIMOCODE_ID_TOKEN = require('./config.js').tokenDaConta() || ''; } catch { env.PRIMOCODE_ID_TOKEN = ''; } }
-        for (const [k, v] of Object.entries(def.headers || {})) h[k.toLowerCase()] = expandir([v], env)[0];
+        for (const [k, v] of Object.entries(def.headers || {})) h[k.toLowerCase()] = expandir([v], env, opcoesDeExpansao(def))[0];
         const tk = nome && lerTokens()[nome];
         if (tk && tk.access_token && !h.authorization) h.authorization = `Bearer ${tk.access_token}`;
         if (sessao) h['mcp-session-id'] = sessao;
@@ -264,6 +353,7 @@ function ouvirCallback(estado, prazoMs) {
 async function entrar(nome, { pasta, abrir = abrirUrl, aviso = () => {}, buscar = globalThis.fetch, prazoMs = 5 * 60000 } = {}) {
     const def = servidores(pasta)[nome];
     if (!def || !def.url) return { ok: false, error: `"${nome}" não é um servidor MCP remoto (type http com url) — veja primocode mcp list` };
+    try { await autorizarProjeto(def, nome); } catch (e) { return { ok: false, error: e.message }; }
     let cb;
     try {
         // Sem token (o do header manual não conta): o 401 diz onde está o OAuth.
@@ -642,6 +732,14 @@ function dica(pasta) {
 /** `primocode mcp …` */
 async function main(argv) {
     const [op, ...resto] = argv;
+    if (!perguntador && process.stdin.isTTY && process.stdout.isTTY) {
+        perguntador = ({ nome, resumo }) => new Promise((res) => {
+            const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
+            rl.question(`O servidor MCP "${nome}" vem do .mcp.json deste projeto e vai rodar: ${resumo}\nIniciar? (s/N) `, (r) => {
+                rl.close(); res(/^(s|sim|y|yes)\b/i.test(String(r).trim()));
+            });
+        });
+    }
     const json = (() => { const i = resto.indexOf('--json'); try { return i >= 0 ? JSON.parse(resto[i + 1] || '{}') : {}; } catch { return null; } })();
     try {
         if (!op || op === 'help') {
@@ -718,4 +816,4 @@ async function main(argv) {
     }
 }
 
-module.exports = { servidores, conectar, listar, chamar, usar, dica, main, procurar, doRegistro, conectarNovo, CURADOS, expandir, entrar, sair, renovarToken };
+module.exports = { usarPerguntador, aprovarProjeto, jaAprovado, hashDoServidor, ENV_PERMITIDAS, servidores, conectar, listar, chamar, usar, dica, main, procurar, doRegistro, conectarNovo, CURADOS, expandir, entrar, sair, renovarToken };

package/lib/memoria-usuario.js

@@ -141,7 +141,7 @@ function carregarIndice(home, max = LINHAS_DO_INDICE) {
     try { t = fs.readFileSync(arquivoIndice(home), 'utf-8'); } catch { return ''; }
     const linhas = t.split('\n').filter((l) => l.trim());
     if (linhas.length <= max) return linhas.join('\n');
-    return linhas.slice(0, max).join('\n') + `\n(… cortado: mais ${linhas.length - max} memórias, use /memoria)`;
+    return linhas.slice(0, max).join('\n') + `\n(… cortado: mais ${linhas.length - max} memórias, use /memory)`;
 }
 
 /** As regras de quando salvar. Entram no contexto junto com o índice. */