primocode 10.17.1 → 11.0.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/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. */

package/lib/mencoes.js

@@ -29,6 +29,12 @@ function lerSeExiste(arquivo) {
     } catch { return ''; }
 }
 
+function soRegras(texto) {
+    const { INICIO, FIM } = require('./regras.js');
+    const i = texto.indexOf(INICIO), f = texto.indexOf(FIM);
+    return i >= 0 && f > i && !(texto.slice(0, i) + texto.slice(f + FIM.length)).trim();
+}
+
 /** O texto que entra no contexto, ou '' se não há instrução nenhuma. */
 function instrucoesDoProjeto(projectDir, limite = LIMITE_INSTRUCOES) {
     const partes = [];
@@ -44,6 +50,10 @@ function instrucoesDoProjeto(projectDir, limite = LIMITE_INSTRUCOES) {
             const texto = require('./agents-md.js').semBloco(lerSeExiste(path.join(projectDir, nome)));
             if (!texto.trim()) continue;
             partes.push(`[${nome} — instruções deste projeto: siga]\n${cortar(texto, limite)}`);
+            /* Um PRIMO.md que só tem as regras do /regra (lib/regras.js) não
+               é o "escrito PARA nós" inteiro: as regras entram, e o AGENTS.md
+               ou o CLAUDE.md do repo ainda têm a vez deles. */
+            if (nome === 'PRIMO.md' && soRegras(texto)) continue;
             break;
         }
     }

package/lib/mostrar.js

@@ -0,0 +1,121 @@
+/**
+ * mostrar.js — o /mostrar: o app aberto no celular de alguém no mesmo Wi-Fi, sem publicar nada.
+ *
+ *   abrir(projectDir, { minutos, agora, porta, host }) → Promise<{ ok, url, urlLocal, fechar(), expira }>
+ *   arquivoPermitido(projectDir, urlPath)               → caminho absoluto | null      (puro na decisão)
+ *
+ * O dia seguinte do iniciante: quer mostrar o app pra família, e "publicar" assusta (Lovable e Bolt separam
+ * "compartilhar uma prévia" de "publicar": docs.lovable.dev/features/projects/preview, support.bolt.new [VERIFICAR]).
+ * Aqui é um servidor na rede local, só enquanto o PrimoCode está aberto, com token no link e prazo (padrão 60 min).
+ * Nunca entrega arquivo ou pasta que começa com ponto (.env, .git), nem node_modules, nem nada fora da pasta — nem
+ * pelo nome com outra caixa (o disco do Mac não diferencia), nem por link simbólico.
+ *
+ * A segunda revisão de 24/10 achou o que corrigir: pedido malformado ("GET //") fazia o new URL lançar e derrubava o
+ * PrimoCode sem token; erro ao ler o arquivo também derrubava; /Node_Modules e um link pra .segredos/ passavam; e o
+ * vídeo não tocava no iPhone (sem Range).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const crypto = require('crypto');
+const { pipeline } = require('stream');
+
+const TIPOS = { '.html': 'text/html; charset=utf-8', '.htm': 'text/html; charset=utf-8', '.css': 'text/css; charset=utf-8', '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8', '.json': 'application/json; charset=utf-8', '.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.ico': 'image/x-icon', '.mp4': 'video/mp4', '.mp3': 'audio/mpeg', '.wav': 'audio/wav',
+    '.woff': 'font/woff', '.woff2': 'font/woff2', '.txt': 'text/plain; charset=utf-8', '.webmanifest': 'application/manifest+json' };
+
+/** Uma parte do caminho que nunca sai: começa com ponto, ou é node_modules em qualquer caixa. */
+const proibida = (p) => p.startsWith('.') || p.toLowerCase() === 'node_modules';
+
+/** O arquivo que pode sair, ou null. `entrada` é a página de quando a raiz não tem index.html (o único .html). */
+function arquivoPermitido(projectDir, urlPath, { entrada = null } = {}) {
+    let rel;
+    try { rel = decodeURIComponent(String(urlPath || '/')); } catch { return null; }
+    if (rel.includes('\0')) return null;
+    const partes = rel.split(/[\\/]/).filter(Boolean);
+    if (partes.some(proibida)) return null;
+    const raiz = path.resolve(projectDir);
+    let abs = path.resolve(raiz, ...partes);
+    if (abs !== raiz && !abs.startsWith(raiz + path.sep)) return null;
+    try {
+        if (fs.statSync(abs).isDirectory()) {
+            const idx = path.join(abs, 'index.html');
+            abs = fs.existsSync(idx) ? idx : (abs === raiz && entrada ? path.join(raiz, entrada) : idx);
+        }
+        const raizReal = fs.realpathSync(raiz), real = fs.realpathSync(abs);
+        if (real !== raizReal && !real.startsWith(raizReal + path.sep)) return null;
+        // o filtro de novo, no caminho de verdade: um link "config.json → .segredos/chaves.json" não passa
+        if (path.relative(raizReal, real).split(path.sep).some(proibida)) return null;
+        return fs.statSync(real).isFile() && TIPOS[path.extname(real).toLowerCase()] ? real : null;
+    } catch { return null; }
+}
+
+function ipDaRede() {
+    for (const lista of Object.values(os.networkInterfaces())) {
+        for (const i of lista || []) if (i.family === 'IPv4' && !i.internal) return i.address;
+    }
+    return null;
+}
+
+/** O pedaço pedido no Range ("bytes=100-" ou "bytes=100-199"), ou null; inválido → { invalido: true }. Puro. */
+function intervalo(cabecalho, tamanho) {
+    const m = String(cabecalho || '').match(/^bytes=(\d*)-(\d*)$/);
+    if (!m) return null;
+    let ini = m[1] === '' ? null : Number(m[1]), fim = m[2] === '' ? null : Number(m[2]);
+    if (ini == null && fim == null) return { invalido: true };
+    if (ini == null) { ini = Math.max(0, tamanho - fim); fim = tamanho - 1; }   // "bytes=-500": os últimos 500
+    if (fim == null || fim >= tamanho) fim = tamanho - 1;
+    if (ini > fim || ini >= tamanho) return { invalido: true };
+    return { ini, fim };
+}
+
+function abrir(projectDir, { minutos = 60, agora = () => Date.now(), porta = 0, host = '0.0.0.0', entrada = null } = {}) {
+    return new Promise((resolve) => {
+        const token = crypto.randomBytes(8).toString('hex');
+        const expira = agora() + minutos * 60000;
+        const srv = http.createServer((req, res) => {
+            const nao = (cod, txt) => { if (!res.headersSent) { res.writeHead(cod, { 'content-type': 'text/plain; charset=utf-8' }); } res.end(txt); };
+            try {
+                // sem new URL: "GET //" fazia ele lançar e derrubava o PrimoCode, sem token nenhum
+                const bruto = String(req.url || '/');
+                const q = bruto.indexOf('?');
+                const caminho = q >= 0 ? bruto.slice(0, q) : bruto;
+                const busca = new URLSearchParams(q >= 0 ? bruto.slice(q + 1) : '');
+                if (agora() > expira) return nao(403, 'Este link do PrimoCode já expirou. Peça um novo.');
+                // o token vem no link (?t=) e fica num cookie, pra página poder carregar o css e o js sem ele
+                const doCookie = ((req.headers.cookie || '').match(/(?:^|;\s*)primo_t=([0-9a-f]{16})/) || [])[1];
+                if ((busca.get('t') || doCookie) !== token) return nao(403, 'Link sem permissão. Use o link inteiro que o PrimoCode mostrou.');
+                const arq = arquivoPermitido(projectDir, caminho, { entrada });
+                if (!arq) return nao(404, 'Não achei.');
+                const tamanho = fs.statSync(arq).size;
+                const base = { 'content-type': TIPOS[path.extname(arq).toLowerCase()], 'cache-control': 'no-store', 'accept-ranges': 'bytes',
+                    'set-cookie': `primo_t=${token}; Path=/; HttpOnly; SameSite=Strict`, 'x-content-type-options': 'nosniff' };
+                // Range: o Safari do iPhone só toca <video> e <audio> pedindo em pedaços
+                const r = intervalo(req.headers.range, tamanho);
+                if (r && r.invalido) { res.writeHead(416, { 'content-range': `bytes */${tamanho}` }); return res.end(); }
+                if (r) res.writeHead(206, { ...base, 'content-range': `bytes ${r.ini}-${r.fim}/${tamanho}`, 'content-length': r.fim - r.ini + 1 });
+                else res.writeHead(200, { ...base, 'content-length': tamanho });
+                if (req.method === 'HEAD') return res.end();
+                // pipeline: erro ao ler (permissão, arquivo apagado) e celular que desiste fecham tudo, sem derrubar nada
+                pipeline(fs.createReadStream(arq, r ? { start: r.ini, end: r.fim } : {}), res, (e) => { if (e) res.destroy(); });
+            } catch { try { nao(400, 'Pedido inválido.'); } catch { res.destroy(); } }
+        });
+        srv.on('clientError', (e, s) => { try { s.end('HTTP/1.1 400 Bad Request\r\n\r\n'); } catch { s.destroy(); } });
+        srv.on('error', (e) => resolve({ ok: false, error: e.message }));
+        srv.listen(porta, host, () => {
+            const p = srv.address().port, ip = ipDaRede();
+            const fechar = () => new Promise((r) => { try { srv.close(() => r()); if (srv.closeAllConnections) srv.closeAllConnections(); } catch { r(); } });
+            const relogio = setTimeout(fechar, minutos * 60000 + 1000);
+            if (relogio.unref) relogio.unref();
+            srv.unref();   // não segura o PrimoCode aberto
+            resolve({ ok: true, url: ip ? `http://${ip}:${p}/?t=${token}` : null, urlLocal: `http://127.0.0.1:${p}/?t=${token}`, expira, fechar, porta: p, token });
+        });
+    });
+}
+
+module.exports = { abrir, arquivoPermitido, intervalo, ipDaRede };