primocode 10.17.1 → 11.0.0

package/lib/motioncraft.js

@@ -0,0 +1,67 @@
+/**
+ * motioncraft.js — `primocode motioncraft <comando>`.
+ *
+ * O MotionCraft (vendor/motioncraft, MIT, de ahmdd4vd) monta o motion:
+ * template Remotion, música e efeitos sintetizados, sincronia, QA de quadro
+ * e render. O que ele NÃO tem é voz. A voz continua sendo a do PrimoCode
+ * (`estudio_narrar`: Edge, ElevenLabs, Kokoro), que devolve as falas com o
+ * tempo MEDIDO; `voz-para-words` entrega esse tempo no formato que o
+ * `timeline build` do MotionCraft lê (audio/words.json).
+ *
+ * Todo o resto é repassado ao CLI do MotionCraft, sem mexer nele.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const CLI = path.join(__dirname, '..', 'vendor', 'motioncraft', 'scripts', 'motioncraft.mjs');
+
+/**
+ * As falas medidas viram palavras com tempo: cada palavra recebe a fatia da
+ * fala proporcional ao tamanho dela (a mesma conta do repartirTrechos do
+ * estúdio). Sem Whisper, é o melhor que o texto permite — e melhor que o
+ * "frase por pausa" do MotionCraft, porque o início e o fim vêm da síntese.
+ */
+function falasParaWords(falas) {
+    const lista = (falas || []).filter((f) => f && f.ate > f.de && String(f.texto || '').trim());
+    const words = [];
+    const phrases = [];
+    for (const f of lista) {
+        const ws = String(f.texto).trim().split(/\s+/);
+        const letras = ws.reduce((n, w) => n + w.length, 0) || 1;
+        let t = f.de;
+        for (const w of ws) {
+            const fim = t + (f.ate - f.de) * (w.length / letras);
+            words.push({ w, start: +t.toFixed(3), end: +fim.toFixed(3) });
+            t = fim;
+        }
+        phrases.push({ start: +f.de.toFixed(3), end: +f.ate.toFixed(3), text: String(f.texto).trim() });
+    }
+    return { mode: 'word', source: 'primocode-narrar', text: words.map((w) => w.w).join(' '), words, phrases };
+}
+
+function main(argv) {
+    const [cmd, ...resto] = argv;
+    if (cmd === 'voz-para-words') {
+        const entrada = resto[0];
+        if (!entrada) { console.error('uso: primocode motioncraft voz-para-words <saida-do-narrar.json> [--out audio/words.json]'); return 1; }
+        const i = resto.indexOf('--out');
+        const saida = path.resolve(i >= 0 ? resto[i + 1] : 'audio/words.json');
+        let dados;
+        try { dados = JSON.parse(fs.readFileSync(entrada, 'utf8')); } catch (e) { console.error(`não li ${entrada}: ${e.message}`); return 1; }
+        const w = falasParaWords(dados.falas || dados);
+        if (!w.words.length) { console.error('o arquivo não tem falas com tempo (esperava "falas": [{de, ate, texto}]).'); return 1; }
+        fs.mkdirSync(path.dirname(saida), { recursive: true });
+        fs.writeFileSync(saida, JSON.stringify(w, null, 1));
+        console.log(JSON.stringify({ ok: true, arquivo: saida, palavras: w.words.length, frases: w.phrases.length }));
+        return 0;
+    }
+    if (!fs.existsSync(CLI)) { console.error('vendor/motioncraft não está neste pacote.'); return 1; }
+    const r = spawnSync(process.execPath, [CLI, ...argv], { stdio: 'inherit' });
+    return r.status == null ? 1 : r.status;
+}
+
+module.exports = { falasParaWords, main, CLI };

package/lib/mudou.js

@@ -0,0 +1,58 @@
+/**
+ * mudou.js — o /mudou: o que mudou no projeto, em português simples, e não um diff.
+ *
+ *   doGit(numstat, porcelana) → { arquivos: [{ arquivo, mais, menos, novo }] }    (puro: lê a saída do git)
+ *   frase(r)                  → "3 arquivos: 1 novo, 2 editados · 40 linhas a mais, 12 a menos"   (puro)
+ *   medir(projectDir)         → { git: true, ... } | { git: false, ... }          (roda o git ou lê o checkpoint)
+ *
+ * Ideia do /diff e do /review do Codex CLI (brechas-3 #3 [VERIFICAR]): o iniciante quer saber o tamanho do que a IA
+ * fez antes de seguir, e o diff cru assusta. Num repositório git, conta contra o último commit (com os arquivos
+ * novos); fora do git, diz o que o último pedido mudou, pelo checkpoint.
+ */
+
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function doGit(numstat, porcelana) {
+    const arquivos = [];
+    for (const l of String(numstat || '').split('\n')) {
+        const m = l.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+        if (m) arquivos.push({ arquivo: m[3], mais: m[1] === '-' ? 0 : Number(m[1]), menos: m[2] === '-' ? 0 : Number(m[2]), novo: false });
+    }
+    // os novos (?? no status) não aparecem no diff: entram contados como novos; o D do status é o apagado
+    for (const l of String(porcelana || '').split('\n')) {
+        const novo = l.match(/^\?\? (.+)$/), apagado = l.match(/^(?: D|D ) (.+)$/);
+        if (novo && !arquivos.some((a) => a.arquivo === novo[1])) arquivos.push({ arquivo: novo[1], mais: null, menos: 0, novo: true });
+        if (apagado) { const a = arquivos.find((x) => x.arquivo === apagado[1]); if (a) a.apagado = true; }
+    }
+    return { arquivos };
+}
+
+const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
+
+function frase({ arquivos = [] } = {}) {
+    if (!arquivos.length) return 'Nada mudou desde o último commit.';
+    const novos = arquivos.filter((a) => a.novo).length, apagados = arquivos.filter((a) => a.apagado).length;
+    const editados = arquivos.length - novos - apagados;
+    const tipos = [novos ? plural(novos, 'novo', 'novos') : '', editados ? plural(editados, 'editado', 'editados') : '', apagados ? plural(apagados, 'apagado', 'apagados') : ''].filter(Boolean).join(', ');
+    const mais = arquivos.reduce((s, a) => s + (a.mais || 0), 0), menos = arquivos.reduce((s, a) => s + (a.menos || 0), 0);
+    const linhas = [mais ? `${plural(mais, 'linha', 'linhas')} a mais` : '', menos ? `${menos} a menos` : ''].filter(Boolean).join(', ');
+    return `${plural(arquivos.length, 'arquivo', 'arquivos')}: ${tipos}` + (linhas ? ` · ${linhas}` : '');
+}
+
+function medir(projectDir, { git = (args) => spawnSync('git', args, { cwd: projectDir, encoding: 'utf8' }), checkpoint = require('./checkpoint.js') } = {}) {
+    const dentro = git(['rev-parse', '--is-inside-work-tree']);
+    if (dentro.status === 0 && String(dentro.stdout).trim() === 'true') {
+        const r = doGit(git(['diff', 'HEAD', '--numstat']).stdout, git(['status', '--porcelain']).stdout);
+        return { git: true, ...r, frase: frase(r) };
+    }
+    const cp = checkpoint.lista(projectDir)[0];
+    if (!cp) return { git: false, arquivos: [], frase: 'Ainda não mudou nada por aqui: nenhum pedido mexeu nos arquivos.' };
+    const arquivos = (cp.mudou || []).map((m) => ({ arquivo: path.relative(projectDir, m.caminho), acao: m.acao }));
+    const qual = `No último pedido ("${String(cp.pedido || '').replace(/\s+/g, ' ').slice(0, 50)}")`;
+    return { git: false, pedido: cp.pedido, arquivos, frase: arquivos.length ? `${qual}: ${plural(arquivos.length, 'arquivo', 'arquivos')}.` : `${qual}, nada mudou nos arquivos.` };
+}
+
+module.exports = { doGit, frase, medir };

package/lib/nomes.js

@@ -0,0 +1,257 @@
+/**
+ * nomes.js — os nomes dos comandos, num lugar só (26/10).
+ *
+ * "Os nomes devem ser em inglês, curtos e bons, e ter uma lógica de intenção
+ * pro usuário não ter que decorar os comandos." Cada comando tem UM nome
+ * (inglês, curto), uma INTENÇÃO (um dos 9 grupos) e a lista dos nomes antigos
+ * que continuam valendo. Ninguém reaprende: `/desfazer` chama o `/undo`.
+ *
+ * É a única tabela. O despachante (bin/primocode.js), o `/help`, o `/` sozinho
+ * e o menu da IA leem daqui; um nome que não está aqui não existe.
+ */
+
+'use strict';
+
+const GRUPOS = [
+    { id: 'comecar', titulo: 'Começar' },
+    { id: 'conversa', titulo: 'Conversa e anexos' },
+    { id: 'volta', titulo: 'Errou? Volta' },
+    { id: 'rodar', titulo: 'Rodar e ver' },
+    { id: 'ar', titulo: 'Pôr no ar' },
+    { id: 'entender', titulo: 'Entender' },
+    { id: 'jeito', titulo: 'Do seu jeito' },
+    { id: 'video', titulo: 'Vídeo e marca' },
+    { id: 'conta', titulo: 'Conta e sistema' },
+];
+
+// nome novo → { grupo, antigos }. `antigos` são os apelidos que continuam valendo.
+const COMANDOS = {
+    // 1. Começar
+    new: { grupo: 'comecar', antigos: ['novo', 'comecar', 'começar', 'start'] },
+    projects: { grupo: 'comecar', antigos: ['projetos', 'project'] },
+    dir: { grupo: 'comecar', antigos: ['cd', 'pasta'] },
+    init: { grupo: 'comecar', antigos: [] },
+    worktree: { grupo: 'comecar', antigos: [] },
+    // 2. Conversa e anexos
+    attach: { grupo: 'conversa', antigos: ['web', 'files'] },
+    detach: { grupo: 'conversa', antigos: [] },
+    compact: { grupo: 'conversa', antigos: [] },
+    clear: { grupo: 'conversa', antigos: [] },
+    cls: { grupo: 'conversa', antigos: [] },
+    chats: { grupo: 'conversa', antigos: ['conversas'] },
+    resume: { grupo: 'conversa', antigos: [] },
+    history: { grupo: 'conversa', antigos: ['historico', 'histórico'] },
+    export: { grupo: 'conversa', antigos: ['exportar'] },
+    copy: { grupo: 'conversa', antigos: ['copiar'] },
+    // 3. Errou? Volta
+    undo: { grupo: 'volta', antigos: ['desfazer', 'rewind'] },
+    redo: { grupo: 'volta', antigos: ['refazer'] },
+    check: { grupo: 'volta', antigos: ['conferir', 'testar'] },
+    restore: { grupo: 'volta', antigos: ['voltar'] },
+    changes: { grupo: 'volta', antigos: ['mudou', 'mudanças', 'mudancas'] },
+    timeline: { grupo: 'volta', antigos: ['linha-do-tempo', 'historia', 'história'] },
+    // 4. Rodar e ver
+    open: { grupo: 'rodar', antigos: ['abrir'] },
+    show: { grupo: 'rodar', antigos: ['mostrar', 'share-local'] },
+    port: { grupo: 'rodar', antigos: ['porta', 'naoabre', 'nao-abre'] },
+    howto: { grupo: 'rodar', antigos: ['como-rodar', 'comorodar'] },
+    map: { grupo: 'rodar', antigos: ['mapa', 'tree'] },
+    read: { grupo: 'rodar', antigos: [] },
+    run: { grupo: 'rodar', antigos: [] },
+    tasks: { grupo: 'rodar', antigos: ['tarefas', 'fundo'] },
+    // 5. Pôr no ar
+    ship: { grupo: 'ar', antigos: ['publicar'] },
+    lock: { grupo: 'ar', antigos: ['trava', 'travar'] },
+    save: { grupo: 'ar', antigos: ['guardar'] },
+    // 6. Entender
+    explain: { grupo: 'entender', antigos: ['explicar', 'explica', 'glossario', 'glossário'] },
+    plan: { grupo: 'entender', antigos: ['antes-de-mexer'] },
+    review: { grupo: 'entender', antigos: ['revisar'] },
+    help: { grupo: 'entender', antigos: ['all', 'tudo', 'capacidades', 'tools'] },
+    // 7. Do seu jeito
+    rule: { grupo: 'jeito', antigos: ['regra', 'regras'] },
+    memory: { grupo: 'jeito', antigos: ['memoria'] },
+    name: { grupo: 'jeito', antigos: [] },
+    mode: { grupo: 'jeito', antigos: [] },
+    effort: { grupo: 'jeito', antigos: ['esforco', 'esforço'] },
+    perms: { grupo: 'jeito', antigos: ['permissoes', 'permissions'] },
+    sandbox: { grupo: 'jeito', antigos: [] },
+    config: { grupo: 'jeito', antigos: [] },
+    keys: { grupo: 'jeito', antigos: ['atalhos', 'shortcuts', 'teclas'] },
+    skills: { grupo: 'jeito', antigos: ['marketplace', 'market', 'install-skill', 'installskill'] },
+    commands: { grupo: 'jeito', antigos: ['comandos'] },
+    schedule: { grupo: 'jeito', antigos: ['agendar', 'agenda'] },
+    'testar-app': { grupo: 'rodar', antigos: [] },
+    pesquisar: { grupo: 'entender', antigos: [] },
+    placar: { grupo: 'entender', antigos: [] },
+    secrets: { grupo: 'jeito', antigos: ['segredos'] },
+    team: { grupo: 'jeito', antigos: ['time', 'equipe'] },
+    // 8. Vídeo e marca
+    videos: { grupo: 'video', antigos: ['vídeos'] },
+    taste: { grupo: 'video', antigos: ['gosto', 'referencias'] },
+    brand: { grupo: 'video', antigos: ['marca'] },
+    mascot: { grupo: 'video', antigos: ['mascote'] },
+    voice: { grupo: 'video', antigos: ['voz'] },
+    styles: { grupo: 'video', antigos: ['estilos', 'kits'] },
+    // 9. Conta e sistema
+    login: { grupo: 'conta', antigos: ['entrar', 'conectar'] },
+    logout: { grupo: 'conta', antigos: [] },
+    account: { grupo: 'conta', antigos: ['conta', 'planos', 'plano', 'assinar', 'assinatura', 'precos'] },
+    usage: { grupo: 'conta', antigos: ['custo', 'cost', 'tokens', 'limite', 'limit'] },
+    api: { grupo: 'conta', antigos: [] },
+    connectors: { grupo: 'conta', antigos: ['conectores'] },
+    doctor: { grupo: 'conta', antigos: ['status', 'doutor', 'medico', 'médico'] },
+    offline: { grupo: 'conta', antigos: ['local'] },
+    version: { grupo: 'conta', antigos: [] },
+    uninstall: { grupo: 'conta', antigos: [] },
+    exit: { grupo: 'conta', antigos: ['quit', 'sair'] },
+};
+
+// Quando usar cada um, em palavras de quem não programa. É a linha do menu que a
+// IA lê (menuParaIA): ela decide por aqui, não por regex. O teste exige uma por comando.
+const QUANDO = {
+    new: 'quer começar um projeto novo do zero (sem nada, faz 3 perguntas pra quem nunca programou)',
+    projects: 'quer ver, abrir ou criar um projeto que já fez',
+    dir: 'quer trabalhar numa pasta que já existe no computador',
+    init: 'quer que ele estude o projeto e escreva as instruções (PRIMO.md)',
+    worktree: 'quer uma cópia do projeto numa branch nova, sem mexer na atual',
+    attach: 'quer mandar um arquivo ou uma página da internet junto do pedido (sem nada, lista os anexos)',
+    detach: 'quer tirar os anexos',
+    compact: 'a conversa ficou longa e pesada',
+    clear: 'quer recomeçar a conversa do zero',
+    cls: 'quer só limpar a tela',
+    chats: 'quer ver as conversas salvas (as do app e do celular)',
+    resume: 'quer continuar uma conversa de antes',
+    history: 'quer achar um pedido antigo',
+    export: 'quer guardar a conversa num arquivo',
+    copy: 'quer copiar a última resposta',
+    undo: 'o último pedido estragou algo e quer voltar atrás',
+    redo: 'desfez sem querer e quer o que foi desfeito de volta',
+    check: 'quer saber se o projeto ainda funciona',
+    restore: 'quebrou e quer voltar pro último ponto que funcionava',
+    changes: 'quer saber o que mudou no projeto',
+    timeline: 'quer ver a história do projeto e voltar a um ponto',
+    open: 'quer abrir o projeto, um arquivo ou um site no navegador',
+    show: 'quer mostrar o app no celular de alguém, sem publicar',
+    port: 'o app não abre ou a porta está errada',
+    howto: 'quer anotar como abrir e testar o projeto',
+    map: 'quer entender o que tem no projeto e o que falta (`/map tree` mostra as pastas)',
+    read: 'quer ler um arquivo',
+    run: 'quer rodar um comando no projeto',
+    tasks: 'quer ver, rodar ou parar o que está em segundo plano',
+    ship: 'quer colocar o projeto no ar, com um link (site ou app simples: ele envia e devolve o link)',
+    save: 'quer guardar o projeto no GitHub, num lugar privado, pra não perder (cria tudo sozinho)',
+    lock: 'quer que o agente só LEIA certos arquivos, sem mexer (`/lock login.js`; sem nada, lista)',
+    explain: 'quer entender o último pedido (sem nada), uma palavra (`/explain commit`) ou o projeto (`/explain projeto`)',
+    plan: 'quer ver os passos e dar o ok antes de ele mexer em qualquer coisa (`/plan <pedido>`)',
+    review: 'quer uma revisão atrás de bugs, em português simples',
+    help: 'quer ver os comandos (`/help all` mostra tudo que ele sabe fazer)',
+    rule: 'quer uma regra que vale sempre ("nunca mexa no logo")',
+    memory: 'quer ver ou apagar o que ele lembra de você',
+    name: 'quer mudar como ele te chama (`/name voz` muda o nome do assistente de voz)',
+    mode: 'quer trocar entre agente, conversa e automático',
+    effort: 'quer mais rápido ou mais esperto',
+    perms: 'quer mudar quando ele pede licença antes de agir',
+    sandbox: 'quer isolar o que o agente roda no computador',
+    config: 'quer ver as preferências',
+    keys: 'quer saber as teclas que ajudam',
+    skills: 'quer ver ou ligar o que ele sabe fazer (`/skills store` abre a loja, `/skills add` instala)',
+    'testar-app': 'quer que o app web se teste sozinho: abre, clica nos fluxos principais e conserta o que der erro',
+    placar: 'quer ver qual modelo grátis acerta mais em cada tipo de tarefa (`/placar`; `/placar zerar` apaga)',
+    pesquisar: 'quer um relatório com fontes sobre um tema (`/pesquisar <tema>` grava em pesquisas/)',
+    schedule: 'quer que um pedido rode sozinho num dia e hora (`/schedule "toda segunda às 9h" <pedido>`; sem nada, lista)',
+    secrets: 'quer ver as chaves que o projeto usa ou guardar uma (`/secrets add NOME`)',
+    commands: 'quer criar ou ver os comandos dele',
+    team: 'quer que outra IA que já tem (claude, codex, gemini, agy, opencode) revise o que ele faz, ou faça junto',
+    videos: 'quer ver os vídeos que já fez',
+    taste: 'quer ver, refazer ou ensinar o gosto de motion (`/taste referencias` com vídeos que curtiu)',
+    brand: 'quer cores, fontes e logo da marca em todo vídeo',
+    mascot: 'quer escolher ou ver os mascotes',
+    voice: 'quer falar com o Primo por voz',
+    styles: 'quer ver os estilos de motion prontos (galeria com capa e preview; `/styles <estilo>`: um)',
+    login: 'quer entrar na conta',
+    logout: 'quer sair da conta neste computador',
+    account: 'quer ver a conta e o plano (`/account plans` mostra os planos e como assinar)',
+    usage: 'quer saber quanto gastou (agora e hoje), quando zera o limite (`/usage limite N`)',
+    api: 'quer usar a própria chave de uma IA',
+    connectors: 'quer saber quem está respondendo os pedidos',
+    doctor: 'algo não funciona e quer um diagnóstico (`/doctor status` só olha o servidor)',
+    offline: 'quer rodar o servidor no próprio computador',
+    version: 'quer saber a versão',
+    uninstall: 'quer remover o PrimoCode',
+    exit: 'quer sair',
+};
+
+// Os que também existem como `primocode <x>` no terminal: a IA pode rodar sozinha.
+const PELO_TERMINAL = { port: 'primocode porta', videos: 'primocode videos', taste: 'primocode gosto', skills: 'primocode skill list' };
+
+// O apelido que também carrega um argumento: /planos vira `/account plans`, /tree vira `/map tree`.
+const PREFIXO = {
+    tree: 'tree',
+    all: 'all', tudo: 'all', capacidades: 'all', tools: 'all',
+    marketplace: 'store', market: 'store', 'install-skill': 'add', installskill: 'add',
+    planos: 'plans', plano: 'plans', assinar: 'plans', assinatura: 'plans', precos: 'plans',
+    status: 'status',
+    limite: 'limite', limit: 'limite',
+    referencias: 'referencias',
+};
+
+// apelido → nome novo (derivada, para nunca divergir de COMANDOS)
+const ANTIGOS = {};
+for (const [novo, x] of Object.entries(COMANDOS)) for (const velho of x.antigos) ANTIGOS[velho] = novo;
+
+const limpo = (nome) => String(nome || '').toLowerCase().replace(/^\//, '');
+
+/** O nome que o despachante entende: apelido vira o nome novo; o resto passa igual. */
+function resolver(nome) {
+    const n = limpo(nome);
+    return Object.prototype.hasOwnProperty.call(ANTIGOS, n) ? ANTIGOS[n] : n;
+}
+
+/** O nome é um apelido antigo (não o nome atual)? Devolve o nome novo, ou null. */
+function ehApelido(nome) {
+    const n = limpo(nome);
+    return Object.prototype.hasOwnProperty.call(ANTIGOS, n) ? ANTIGOS[n] : null;
+}
+
+/** [{ id, titulo, comandos: ['new', ...] }], na ordem dos 9 grupos. */
+function agrupados() {
+    return GRUPOS.map((g) => ({ ...g, comandos: Object.keys(COMANDOS).filter((n) => COMANDOS[n].grupo === g.id) }));
+}
+
+/** Nomes que começam com o prefixo; sem nenhum, os apelidos que começam (devolvidos como nome novo). */
+function porPrefixo(prefixo) {
+    const p = limpo(prefixo);
+    if (!p) return [];
+    const achou = new Set(Object.keys(COMANDOS).filter((n) => n.startsWith(p)));
+    if (!achou.size) for (const [velho, novo] of Object.entries(ANTIGOS)) if (velho.startsWith(p)) achou.add(novo);
+    return [...achou];
+}
+
+
+/**
+ * O menu que a IA lê: um bloco por intenção, uma linha por comando com o "quando".
+ * Quem decide é o modelo: a pessoa diz "põe no ar" e ele aponta o /ship (ou
+ * cumpre o pedido, nos de fábrica). Nada de regex escolhendo comando.
+ * `dela` são os comandos .md da pessoa e do projeto, que não estão na tabela.
+ */
+function menuParaIA({ dela = [] } = {}) {
+    const linhas = ['[comandos] O PrimoCode tem comandos que a pessoa digita com /. Se o pedido dela é o que um deles faz, '
+        + 'diga em uma frase qual digitar (ex.: "digite /undo") — ou, se ela só quer que se resolva, faça você. '
+        + 'Os marcados [roda] você pode rodar com run_shell. Nunca invente comando que não está aqui.'];
+    for (const g of agrupados()) {
+        linhas.push(`${g.titulo}:`);
+        for (const n of g.comandos) {
+            const quando = QUANDO[n];
+            if (!quando) continue;
+            linhas.push(`- /${n} — ${quando}${PELO_TERMINAL[n] ? ` [roda: ${PELO_TERMINAL[n]}]` : ''}`);
+        }
+    }
+    const meus = dela.filter((x) => !COMANDOS[x.nome]);
+    if (meus.length) {
+        linhas.push('Os dela:');
+        for (const x of meus) linhas.push(`- /${x.nome} — ${String(x.descricao || 'comando da pessoa').replace(/\s+/g, ' ').slice(0, 80)}`);
+    }
+    return linhas.join('\n');
+}
+module.exports = { PREFIXO, QUANDO, PELO_TERMINAL, menuParaIA, GRUPOS, COMANDOS, ANTIGOS, resolver, ehApelido, agrupados, porPrefixo };

package/lib/partes.js

@@ -0,0 +1,39 @@
+/**
+ * partes.js — o pedido grande, já escrito em lista, feito uma parte de cada vez.
+ *
+ *   dividir(texto)            → { contexto, partes } | null      (puro)
+ *   pedidoDaParte(div, i)     → o texto do pedido da parte i      (puro)
+ *
+ * A pesquisa de concorrentes (brechas-2 #2): o pedido enorme num prompt só entra em laço e gasta à toa; em partes,
+ * cada uma testada, ele anda. Regra da casa: regex só SUGERE. Só conta pedido que a própria pessoa escreveu em lista
+ * (4 itens ou mais com "-", "•" ou "1."), e quem decide fazer em partes é ela, respondendo a pergunta.
+ */
+
+'use strict';
+
+const ITEM = /^\s*(?:[-*•]|\d{1,2}[.)])\s+(.+?)\s*$/;
+const MINIMO = 4;
+
+function dividir(texto) {
+    const partes = [], resto = [];
+    for (const linha of String(texto || '').split('\n')) {
+        const m = linha.match(ITEM);
+        if (m && m[1].replace(/[^\p{L}\p{N}]/gu, '').length >= 3) partes.push(m[1]);
+        else if (linha.trim()) resto.push(linha.trim());
+    }
+    if (partes.length < MINIMO) return null;
+    return { contexto: resto.join('\n'), partes };
+}
+
+function pedidoDaParte({ contexto, partes }, i) {
+    const n = partes.length;
+    const depois = partes.slice(i + 1);
+    return [
+        contexto,
+        `O pedido tem ${n} partes, feitas uma de cada vez. Agora faça SÓ a parte ${i + 1} de ${n}: ${partes[i]}`,
+        i > 0 ? `As partes de antes já foram feitas: ${partes.slice(0, i).join('; ')}.` : '',
+        depois.length ? `Não comece as próximas ainda (${depois.join('; ')}): elas vêm nos pedidos seguintes.` : 'É a última parte.',
+    ].filter(Boolean).join('\n\n');
+}
+
+module.exports = { dividir, pedidoDaParte, MINIMO };

package/lib/passagem.js

@@ -47,4 +47,33 @@ function montar({ pedido, motivo, registro, falhasPendentes = [] }) {
     return L.join('\n');
 }
 
-module.exports = { montar };
+/* ── a linha da abertura: "da última vez você pediu X e ficou faltando Y" ──────────────────────────────────────────
+   Lê a última entrada do memory.md da pasta, no formato que `montar` (parada) ou o fim normal do pedido escrevem. */
+
+const limpar = (t, n) => {
+    const x = String(t || '').replace(/\s+/g, ' ').replace(/\*\*/g, '').trim();
+    const frase = x.split(/(?<=[.!?])\s/)[0] || x;
+    return frase.length > n ? frase.slice(0, n - 1).trimEnd() + '…' : frase;
+};
+const campo = (bloco, nome) => { const m = bloco.match(new RegExp(`\\*\\*${nome}[^*]*:\\*\\*\\s*([^\\n]*)`)); return m ? m[1].trim() : ''; };
+
+/**
+ * @param {string} memoria  o memory.md inteiro da pasta
+ * @param {{agora?: Date, dias?: number}} [o]  entrada mais velha que `dias` (30) não puxa conversa
+ * @returns {string|null} uma linha em português, ou null se não há o que continuar
+ */
+function linhaDeAbertura(memoria, { agora = new Date(), dias = 30 } = {}) {
+    const blocos = String(memoria || '').split(/^### /m).slice(1);
+    const ultimo = blocos[blocos.length - 1];
+    if (!ultimo) return null;
+    const data = ultimo.match(/^(\d{4})-(\d{2})-(\d{2})/);
+    if (data && (agora - new Date(Number(data[1]), Number(data[2]) - 1, Number(data[3]))) > dias * 86400000) return null;
+    const pedido = limpar(campo(ultimo, 'Pedido'), 70);
+    if (!pedido) return null;
+    const parou = /Pedido \(NÃO concluído\)/.test(ultimo);
+    const faltou = parou ? limpar(campo(ultimo, 'O que falhou') || campo(ultimo, 'Por que parei'), 90) : '';
+    const fim = parou ? (faltou ? `e ficou faltando: ${faltou}` : 'e não terminou') : 'e ficou pronto';
+    return `da última vez você pediu "${pedido}" ${fim} — continuar? (/resume)`;
+}
+
+module.exports = { montar, linhaDeAbertura };

package/lib/perigo.js

@@ -26,9 +26,10 @@
 const os = require('os');
 const path = require('path');
 const protecao = require('./protecao');
+const trava = require('./trava');
 
 const MODOS = ['auto', 'perguntar', 'livre', 'plano'];
-const COMANDOS = new Set(['run_shell', 'run_in_new_terminal']);
+const COMANDOS = new Set(['run_shell', 'run_in_new_terminal', 'run_background']);
 const ESCRITAS = new Set(['write_file', 'edit_file', 'multi_edit']);
 
 function normalizarModo(m) {
@@ -125,6 +126,12 @@ function analisarTrecho(palavras, estado) {
     if ((cmd === 'sh' || cmd === 'bash' || cmd === 'zsh') && args[0] === '-c' && args[1]) {
         return analisarComando(args[1], estado.cwd, estado.projeto, estado.baixados);
     }
+    // `python3 -c`, `node -e`: o SQL dentro do código do interpretador (o furo do teste real de 24/10).
+    if (/^(python[\d.]*|node|bun|deno|ruby|perl|php)$/.test(cmd)) {
+        const i = args.findIndex((x) => /^-[ce]$|^--eval$/.test(x));
+        const r = i >= 0 && args[i + 1] ? apagaBancoNoCodigo(args[i + 1]) : null;
+        if (r) return r;
+    }
     if (cmd === 'rm' || cmd === 'rmdir' || cmd === 'trash') {
         const recursivo = cmd === 'rmdir' || tem(/^-[a-zA-Z]*[rR]|^--recursive$/);
         for (const a of alvos) {
@@ -190,8 +197,52 @@ function mexeNoLivro(palavras, cwd) {
     return p.slice(1).some((x) => !/^-/.test(x) && noLivro(x.split(/>>?/)[0]));
 }
 
+/* Apagar o BANCO: o `rm` acima olha arquivo, e isto não é arquivo nenhum. "Apagou o banco de produção" é a
+   queixa que mais volta no fórum do Replit (replit.discourse.group, fev/2026), e um Postgres ou um Supabase não
+   voltam com /undo: a foto do checkpoint só vê a pasta. DELETE com WHERE e migração comum passam direto. */
+const APAGA_BANCO = [
+    [/\bDROP\s+(?:TABLE|DATABASE|SCHEMA)\b/i, 'apaga uma tabela ou o banco inteiro (DROP)'],
+    [/\bTRUNCATE\s+(?:TABLE\s+)?[\w."`]/i, 'esvazia uma tabela do banco (TRUNCATE)'],
+    [/\bDELETE\s+FROM\s+[\w."`]+\s*(?:;|["']|$)/im, 'apaga todas as linhas de uma tabela (DELETE sem WHERE)'],
+    [/\bprisma\s+(?:migrate\s+reset|db\s+push\b[^;&|]*--(?:force-reset|accept-data-loss))/i, 'zera o banco pelo Prisma (os dados somem)'],
+    [/\b(?:rails|rake)\s+db:(?:drop|reset|schema:load)\b/i, 'zera o banco pelo Rails (os dados somem)'],
+    [/\bmanage\.py\s+flush\b/i, 'esvazia o banco pelo Django (os dados somem)'],
+    [/\bsupabase\s+db\s+reset\b/i, 'zera o banco do Supabase (os dados somem)'],
+    [/\bsequelize(?:-cli)?\s+db:drop\b|\bknex\s+migrate:rollback\b[^;&|]*--all\b/i, 'apaga o banco ou desfaz todas as migrações'],
+];
+function apagaBanco(s) {
+    const achado = APAGA_BANCO.find(([re]) => re.test(s));
+    return achado ? `${achado[1]}: isso não volta com /undo` : null;
+}
+
+/* No código de um `python3 -c`, o DELETE vem montado: `"DELETE FROM " + t`, `execute(\"DELETE FROM x\")`. Aqui
+   vale qualquer DELETE FROM que não tenha WHERE antes do fim do texto (aspa, ; ou quebra de linha). */
+function apagaBancoNoCodigo(codigo) {
+    return apagaBanco(codigo)
+        || (/\bDELETE\s+FROM\b(?![^;'"`\n]*\bWHERE\b)/i.test(codigo) ? 'apaga todas as linhas de uma tabela (DELETE sem WHERE): isso não volta com /undo' : null);
+}
+
+/* O comando apaga dado de banco? É o que dispara a cópia (lib/backup-banco.js). Olha o texto, o `sh -c` e o código
+   de um `python3 -c`/`node -e`, igual ao portão. */
+function apagaBancoNoComando(comando, profundidade = 0) {
+    const s = String(comando || '');
+    if (apagaBanco(s)) return true;
+    if (profundidade > 2) return false;
+    for (const t of trechos(s)) {
+        const [cmd, ...args] = t.palavras.map((x, i) => (i === 0 ? path.basename(x) : x));
+        if (/^(sh|bash|zsh)$/.test(cmd) && args[0] === '-c' && args[1] && apagaBancoNoComando(args[1], profundidade + 1)) return true;
+        if (/^(python[\d.]*|node|bun|deno|ruby|perl|php)$/.test(cmd)) {
+            const i = args.findIndex((x) => /^-[ce]$|^--eval$/.test(x));
+            if (i >= 0 && args[i + 1] && apagaBancoNoCodigo(args[i + 1])) return true;
+        }
+    }
+    return false;
+}
+
 function analisarComando(comando, cwd, projeto, baixados = null) {
     const s = String(comando || '');
+    const banco = apagaBanco(s);
+    if (banco) return banco;
     // Baixar e rodar na hora: o que roda é o que o site mandar naquele segundo.
     if (/\b(curl|wget)\b[^;&]*\|\s*(sudo\s+)?(env\s+)?(ba|z|da|k)?sh\b/.test(s)) {
         return 'baixa um script da internet e roda sem ler';
@@ -258,6 +309,20 @@ function somenteLeitura(comando) {
     });
 }
 
+/* O rótulo de risco em português, na pergunta do modo "perguntar" (ideia do modo writes do Codex CLI, brechas-3 #4
+   [VERIFICAR]): quem pergunta de tudo cansa, mas "rodar: npm i lodash" sozinho não diz se é leitura ou instalação.
+   Puro. Na dúvida, "muda coisa". */
+const INSTALA = /(^|[\s;&|])(npm\s+(i|install|add|ci)\b|pnpm\s+(i|install|add)\b|yarn\s+(add|install)\b|pip3?\s+install\b|brew\s+install\b|apt(-get)?\s+install\b|cargo\s+install\b|go\s+install\b|npx\s|uvx\s|curl\b[^|]*\|\s*(ba|z)?sh)/;
+const APAGA = /(^|[\s;&|])(rm|rmdir|mv|unlink|shred|truncate)\s|git\s+(reset|clean|checkout\s+--|push\s+--force|push\s+-f)\b/;
+function rotulo(comando) {
+    const s = String(comando || '');
+    if (apagaBanco(s)) return 'apaga dados do banco';
+    if (somenteLeitura(s)) return 'só lê';
+    if (INSTALA.test(s)) return 'instala coisa';
+    if (APAGA.test(s)) return 'apaga ou reescreve';
+    return 'muda coisa';
+}
+
 function sha256(t) { return require('crypto').createHash('sha256').update(String(t)).digest('hex'); }
 
 function chaveDoPerigo(nome, args) {
@@ -281,12 +346,15 @@ function emFila(fn) { const p = fila.then(fn, fn); fila = p.catch(() => {}); ret
  */
 async function portao(estado, { modo, nome, args, projectDir, subagent = false, perguntar = null }) {
     const m = normalizarModo(modo);
+    // O /lock vale em TODO modo, até no livre: arquivo travado o agente só lê (lib/trava.js).
+    const travado = trava.recusa(nome, args, projectDir);
+    if (travado) return { ok: false, motivo: travado.motivo, error: travado.error };
     if (m === 'livre') return { ok: true };
     if (m === 'plano') {
         const mexe = ESCRITAS.has(nome) || nome === 'mcp_conectar'
             || (COMANDOS.has(nome) && !somenteLeitura((args || {}).command));
         if (mexe) {
-            return { ok: false, motivo: 'modo plano', error: 'Recusado: o modo plano só lê. Investigue com read_file, grep e comandos de leitura, e entregue o plano; a pessoa muda de modo (/permissoes auto) para executar.' };
+            return { ok: false, motivo: 'modo plano', error: 'Recusado: o modo plano só lê. Investigue com read_file, grep e comandos de leitura, e entregue o plano; a pessoa muda de modo (/perms auto) para executar.' };
         }
         return { ok: true };
     }
@@ -297,7 +365,7 @@ async function portao(estado, { modo, nome, args, projectDir, subagent = false,
 
     const motivo = perigoso ? motivoPerigo
         : tipo === 'comando' ? (nome === 'mcp_usar' ? `usar ${(args || {}).servidor}.${(args || {}).ferramenta}`
-            : `rodar: ${String((args || {}).command || '').slice(0, 80)}`)
+            : `rodar (${rotulo((args || {}).command)}): ${String((args || {}).command || '').slice(0, 80)}`)
             : `escrever ${String((args || {}).path || 'um arquivo')}`;
     const recusa = (texto) => ({ ok: false, motivo, error: texto });
 
@@ -311,7 +379,7 @@ async function portao(estado, { modo, nome, args, projectDir, subagent = false,
             + 'deixe esse passo para o agente principal e diga no seu resumo o que falta fazer.');
     }
     const chave = `${nome}:${JSON.stringify(args || {})}`;
-    const negado = `A pessoa não autorizou: ${motivo}. Siga por outro caminho ou pergunte.`;
+    const negado = `A pessoa não autorizou: ${motivo}. Não faça o mesmo por outro comando (python -c, node -e, script): conte na resposta que isso foi recusado e siga sem ele, ou pergunte.`;
     if (estado.negados.has(chave)) return recusa(negado);
     // "A sessão inteira" libera o TIPO de pergunta: no perigoso, aquele motivo
     // (um push --force autorizado não autoriza um rm -rf ~); no modo
@@ -320,7 +388,7 @@ async function portao(estado, { modo, nome, args, projectDir, subagent = false,
     const liberacao = perigoso ? `perigo:${motivo}${nome === 'mcp_conectar' ? ':' + sha256(chaveDoPerigo(nome, args)) : ''}` : tipo;
     if (estado.liberados.has(liberacao)) return { ok: true };
     if (typeof perguntar !== 'function') {
-        return recusa(`Recusado: ${motivo}. Isso precisa de autorização e não há ninguém para autorizar neste modo.`);
+        return recusa(`Recusado: ${motivo}. Isso precisa de autorização e não há ninguém para autorizar neste modo. Não faça o mesmo por outro comando: conte na resposta que isso foi recusado.`);
     }
 
     const resposta = await emFila(() => perguntar(motivo, { tipo, motivo, primeira: false }));
@@ -330,4 +398,4 @@ async function portao(estado, { modo, nome, args, projectDir, subagent = false,
     return recusa(negado);
 }
 
-module.exports = { somenteLeitura, classificar, portao, novo, normalizarModo, trechos, MODOS };
+module.exports = { apagaBancoNoComando, somenteLeitura, rotulo, classificar, portao, novo, normalizarModo, trechos, MODOS };