primocode 9.5.0 → 9.6.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.5.0
+# PrimoCode v9.6.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.5.0
+ ▐▛███▜▌   Primo Code v9.6.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -59,6 +59,7 @@ const VERSION = pkg.version;
 const state = {
     config: cfg.loadConfig(),
     history: [],
+    resumindo: null,   // o resumo da última rodada, sendo feito em segundo plano
     mode: null,        // 'primocode' | 'chat' | 'auto' — vem da config em main()
     modoEfetivo: null, // no auto, o modo que o último pedido usou de fato
     attachedFiles: [],
@@ -427,20 +428,88 @@ async function confirm(question) {
 
 // ── Projetos ───────────────────────────────────────────────────────────
 
-const STOPWORDS = new Set([
-    'crie', 'cria', 'criar', 'faca', 'faça', 'faz', 'fazer', 'monte', 'montar',
-    'desenvolva', 'desenvolver', 'construa', 'construir', 'gere', 'gerar',
-    'quero', 'queria', 'gostaria', 'preciso', 'me', 'meu', 'minha', 'favor',
-    'um', 'uma', 'uns', 'umas', 'o', 'a', 'os', 'as', 'por', 'pra', 'para',
+/* ── O NOME DO PROJETO ───────────────────────────────────────────────────
+ * O nome saía das cinco primeiras palavras depois de "crie um": "agora deixa o
+ * carro mais rápido" virava a pasta `agora-deixa-o-carro-mais`, e "oi primo,
+ * faz um site" virava `oi-primo-faz-um-site`. Agora o começo da frase
+ * (saudação, o nome dele, verbo de pedido, artigo) é pulado, o assunto vai até
+ * a primeira palavra que emenda outra ideia ("com", "que", "usando"…), e
+ * sobram até quatro palavras que dizem O QUE é: "jogo de carro", "site
+ * padaria", "loja roupas". */
+const ABERTURA = new Set([
+    'oi', 'ola', 'ei', 'hey', 'e', 'ai', 'primo', 'bom', 'boa', 'dia', 'tarde', 'noite', 'ok', 'beleza',
+    'entao', 'agora', 'tipo', 'por', 'favor', 'pfv', 'pf', 'voce', 'vc', 'pode', 'poderia', 'consegue',
+    'crie', 'cria', 'criar', 'faca', 'faz', 'fazer', 'monte', 'monta', 'montar', 'desenvolva', 'desenvolver',
+    'construa', 'construir', 'gere', 'gera', 'gerar', 'programe', 'programa', 'escreva', 'escreve',
+    'quero', 'queria', 'gostaria', 'preciso', 'precisamos', 'vamos', 'bora', 'me', 'pra', 'para', 'mim',
+    'um', 'uma', 'uns', 'umas', 'o', 'a', 'os', 'as', 'de', 'novo', 'nova', 'outro', 'outra', 'projeto',
+    'simples', 'pequeno', 'pequena', 'rapido', 'bonito', 'bonita',
+    // os verbos de CONTINUAR: sem eles, "agora deixa o carro…" virava nome
+    'deixa', 'deixe', 'continua', 'continue', 'edita', 'edite', 'muda', 'mude', 'melhora', 'melhore',
+    'adiciona', 'adicione', 'coloca', 'coloque', 'poe', 'bota', 'corrige', 'corrija', 'arruma', 'arrume',
+    'ajusta', 'ajuste', 'abre', 'abra', 'termina', 'termine',
 ]);
+const EMENDA = new Set(['com', 'que', 'usando', 'onde', 'mas', 'porque', 'igual', 'como', 'sobre',
+    'em', 'no', 'na', 'nos', 'nas', 'e', 'tipo', 'estilo', 'feito', 'utilizando', 'mais', 'menos']);
+// Palavras que não dizem o que a coisa É — saem de qualquer posição.
+const DE_ENCHER = new Set(['minha', 'meu', 'minhas', 'meus', 'nossa', 'nosso', 'para', 'pra', 'uma', 'um',
+    'simples', 'bonito', 'bonita', 'pequeno', 'pequena', 'legal', 'rapido', 'rapida', 'basico', 'basica',
+    'completo', 'completa', 'novo', 'nova']);
+
+function semAcento(x) { return String(x || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase(); }
 
-// "crie um jogo de carro" -> "jogo de carro"
 function deriveProjectName(text) {
-    const words = String(text).trim().split(/\s+/);
+    const palavras = String(text || '').split(/\s+/)
+        .map((w) => w.replace(/[^\wáéíóúâêôãõçÁÉÍÓÚÂÊÔÃÕÇ-]/gi, ''))
+        .filter(Boolean);
     let i = 0;
-    while (i < words.length && STOPWORDS.has(words[i].toLowerCase().replace(/[^\wáéíóúâêôãõç]/gi, ''))) i++;
-    const picked = words.slice(i, i + 5).join(' ').replace(/[^\w\sáéíóúâêôãõçÁÉÍÓÚÂÊÔÃÕÇ-]/gi, '').trim();
-    return picked || 'projeto';
+    while (i < palavras.length && ABERTURA.has(semAcento(palavras[i]))) i++;
+    const assunto = [];
+    for (; i < palavras.length && assunto.length < 6; i++) {
+        const w = semAcento(palavras[i]);
+        if (assunto.length && EMENDA.has(w)) break;
+        if (DE_ENCHER.has(w)) continue;
+        assunto.push(palavras[i]);
+    }
+    while (assunto.length && /^(de|do|da|dos|das)$/i.test(semAcento(assunto[assunto.length - 1]))) assunto.pop();
+    const nome = assunto.slice(0, 4).join(' ').trim();
+    return nome || 'projeto';
+}
+
+/* ── "CRIE UM…" DENTRO DE UM PROJETO ────────────────────────────────────
+ * Depois de entrar num projeto, TUDO ia para ele — até "crie um site de
+ * receitas" no meio do jogo de carro. E fora dele, qualquer "continua" virava
+ * projeto novo. A regra agora: dentro de um projeto, só um pedido que CLARAMENTE
+ * abre outra coisa sai dele — verbo de criar + "um/uma/outro/novo", assunto
+ * que não tem nada a ver com o projeto atual, e nenhuma referência a ele
+ * ("isso", "esse", "nele"). Todo o resto ("continua", "muda a cor", "agora
+ * põe fases") fica. */
+const RE_PROJETO_NOVO = /\b(novo projeto|projeto novo|outro projeto|do zero|come[cç]a(r)? (um|uma|outro|outra))\b/;
+const RE_CRIAR_UM = /\b(crie|cria|criar|fa[cç]a|faz|fazer|monte|monta|montar|gere|gera|desenvolva|construa|programe|quero|preciso de)\s+(um|uma|outro|outra|novo|nova)\b/;
+const RE_REFERE_ATUAL = /\b(isso|isto|esse|essa|este|esta|nele|nela|dele|dela|no projeto|nesse|nessa|neste|nesta|continua|continue|edita|edite|muda|mude|melhora|melhore|adiciona|adicione|coloca|coloque|p[oõ]e|corrige|corrija|arruma|arrume|ajusta|ajuste)\b/;
+
+function pedeProjetoNovo(texto) {
+    const t = semAcento(texto);
+    if (RE_PROJETO_NOVO.test(t)) return true;
+    if (!RE_CRIAR_UM.test(t) || RE_REFERE_ATUAL.test(t)) return false;
+    // Mesmo assunto do projeto atual ("crie uma fase nova pro jogo de carro")
+    // é continuação, não projeto novo.
+    const atual = new Set(cfg.slugify(state.currentProject || '').split('-').filter((x) => x.length > 2));
+    const pedido = cfg.slugify(deriveProjectName(texto)).split('-').filter((x) => x.length > 2);
+    return !pedido.some((x) => atual.has(x));
+}
+
+/* Pedido de mexer no computador da pessoa (abrir app, clicar, digitar,
+   mostrar o cursor). Serve só para mandar a dica das ferramentas desktop_*. */
+const RE_COMPUTADOR = /\b(abr[ae]|abrir|clica|clique|clicar|digita|digite|digitar|mouse|cursor|teclado|meu computador|no (meu )?mac|na (minha )?tela|aplicativo|spotify|safari|finder|whatsapp|mensagens|m[úu]sica|configura[çc][õo]es|ajustes)\b/i;
+function querComputador(texto) { return RE_COMPUTADOR.test(String(texto || '')); }
+
+/* Guarda onde se está, para a próxima sessão continuar aqui. */
+function entrarNoProjeto(dir, origem = 'projeto') {
+    state.workDir = dir;
+    state.currentProject = path.basename(dir);
+    state.workDirOrigem = origem;
+    cfg.lembrarProjeto(dir, origem);
 }
 
 // Pasta em que é seguro deixar um agente criar e editar arquivo. A home e a raiz
@@ -477,7 +546,10 @@ function ehSoEstudio(texto) {
 }
 
 function planWorkDir(userText) {
-    if (['/dir', 'detectada', 'projeto'].includes(state.workDirOrigem)) {
+    const escolhida = ['/dir', 'detectada', 'projeto'].includes(state.workDirOrigem);
+    // Pasta escolhida a dedo (/dir, ou dita no pedido) manda sempre. Projeto
+    // em andamento manda também — a menos que o pedido abra outra coisa.
+    if (escolhida && !(state.workDirOrigem === 'projeto' && pedeProjetoNovo(userText))) {
         return { dir: state.workDir, pending: false, name: state.currentProject };
     }
     // "Quando eu peço um vídeo, não é pra ficar com projeto. Só vai criar
@@ -493,9 +565,7 @@ function planWorkDir(userText) {
 
 function createPendingProject(plan) {
     const dir = cfg.createProjectDir(plan.name);
-    state.workDir = dir;
-    state.currentProject = path.basename(dir);
-    state.workDirOrigem = 'projeto';
+    entrarNoProjeto(dir, 'projeto');
     const rotulo = plan.similar ? 'Continuando em' : 'Projeto novo:';
     console.log(c.ok(`  ${rotulo} ${state.currentProject}`) + c.muted(`  (${dir})`));
     refreshPrompt();
@@ -530,9 +600,7 @@ function talvezTrocarDePasta(userText) {
     if (path.resolve(achado.caminho) === path.resolve(projectDir())) return;  // já está lá
     if (!pastaSegura(achado.caminho)) return;   // home ou raiz: só por /dir explícito
 
-    state.workDir = achado.caminho;
-    state.currentProject = path.basename(achado.caminho);
-    state.workDirOrigem = 'detectada';
+    entrarNoProjeto(achado.caminho, 'detectada');
     console.log(c.ok(`  Trabalhando em ${shortPath(achado.caminho)}`) + c.dim(`  (você falou "${candidato}")`));
     refreshPrompt();
 }
@@ -556,9 +624,7 @@ function prepararPasta(userText) {
     // buildMemoryContext deste turno leria a pasta errada e a memória do projeto
     // não carregaria.
     if (!plan.pending && path.resolve(plan.dir) !== path.resolve(projectDir())) {
-        state.workDir = plan.dir;
-        state.currentProject = plan.name || path.basename(plan.dir);
-        state.workDirOrigem = 'projeto';
+        entrarNoProjeto(plan.dir, 'projeto');
         console.log(c.ok(`  Continuando em ${state.currentProject}`) + c.muted(`  (${shortPath(plan.dir)})`));
         refreshPrompt();
     }
@@ -602,6 +668,20 @@ async function autorizarControle(oQueVaiFazer, { primeira } = {}) {
     return 'nao';
 }
 
+/* ── A PERMISSÃO NO MODO VOZ ─────────────────────────────────────────────
+ * No modo voz ninguém está olhando o terminal: a pergunta "1, 2 ou Enter"
+ * ficava lá embaixo, o agente parava esperando, e para quem só falava ele
+ * simplesmente travava. Abrir o /voice e PEDIR em voz para ele mexer no
+ * computador já é a autorização — é o produto funcionando como o Jarvis. Fica
+ * dito no terminal, a cada ação, o que ele fez; e fechar o PrimoCode esquece. */
+async function autorizarPorVoz(oQueVaiFazer, { primeira } = {}) {
+    if (primeira) {
+        console.log('  ' + c.warn('▸▸') + ' ' + c.muted('Modo voz: o Primo vai usar o mouse e o teclado. Você vê o cursor dele na tela.'));
+    }
+    console.log('  ' + c.brand('●') + ' ' + c.dim(oQueVaiFazer));
+    return 'sessao';
+}
+
 /* ── A TELA DO MARKETPLACE ───────────────────────────────────────────────
  * O desenho e as teclas vivem em lib/marketplace.js, que é função pura. O que
  * mora aqui é o que precisa do terminal: tirar a caixa de digitar da frente,
@@ -801,10 +881,9 @@ async function sendPrompt(userText) {
 
         const plan = prepararPasta(userText);
 
-        // Antes de gastar com a tarefa, dobra no resumo o que já passou. A
-        // conta é pequena: entra "resumo de antes + o que é novo", não a
-        // conversa inteira.
-        await comprimirConversa();
+        // O resumo da rodada anterior é feito em segundo plano logo depois
+        // dela; aqui só se espera ele terminar, para não sair com memória velha.
+        await esperarResumo();
 
         // O pedido passa por uma cabeça antes de virar trabalho: conserta o
         // que está torto, diz qual é o entregável e o que conta como pronto.
@@ -842,7 +921,7 @@ async function sendPrompt(userText) {
                 token: state.config.token,
                 // Só o primeiro passo enxerga a conversa: os seguintes recebem o
                 // que interessa em `jaFeito`, e conversa a mais só ocupa o teto.
-                history: i === 0 ? memoria.paraEnviar(state.memoria, state.history) : [],
+                history: i === 0 ? memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()) : [],
                 projectDir: plan.dir,
                 projectName: plan.name || state.currentProject,
                 // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
@@ -852,6 +931,9 @@ async function sendPrompt(userText) {
                 // lembra da resposta é a sessão.
                 autorizar: autorizarControle,
                 controle: state.controle,
+                // Pedido de mexer no computador leva a dica que libera as
+                // ferramentas desktop_* no servidor (ver DICA_COMPUTADOR).
+                instrucao: i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '',
             });
 
             r = await rodarPasso();
@@ -877,6 +959,7 @@ async function sendPrompt(userText) {
         if (balanco) console.log(balanco);
         state.history.push({ role: 'user', content: userText });
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
+        resumirDepois();
         state.lastResponse = r.assistantMessage.content;
         cfg.appendHistory({ mode: 'primocode', project: state.currentProject, prompt: userText });
         // Sobe cifrado, atrás, sem segurar o prompt. Se não houver conta ou
@@ -884,7 +967,7 @@ async function sendPrompt(userText) {
         state.gravador.turno(userText, r.assistantMessage.content,
             { modo: 'primocode', projeto: state.currentProject || null });
     } else {
-        await comprimirConversa();
+        await esperarResumo();
         await runChat(prompt, userText);
     }
 
@@ -986,21 +1069,55 @@ async function dividirTarefa(pedido) {
    resumir. Sem isso o comando responderia "nada a fazer" justamente quando
    ela está vendo a IA se perder — e "não fiz nada" é a pior resposta possível
    para quem acabou de pedir socorro. */
-async function comprimirConversa(forcado = false) {
+async function comprimirConversa(forcado = false, { silencioso = false } = {}) {
     if (!forcado && !memoria.precisaResumir(state.memoria, state.history)) return;
-    const sp = new Spinner('resumindo a conversa').start();
+    // Em segundo plano não há spinner: ele disputaria a tela com o prompt.
+    const sp = silencioso ? { stop() {} } : new Spinner('resumindo a conversa').start();
     try {
-        state.memoria = await memoria.atualizar(state.memoria, state.history, ({ resumo, mensagens }) =>
+        const conversa = state.history;
+        const nova = await memoria.atualizar(state.memoria, conversa, ({ resumo, mensagens }) =>
             api.requestResumo(state.config.server, { resumo, mensagens, token: state.config.token })
                 .then((r) => r.resumo));
+        // /clear ou /chats trocaram a conversa enquanto o resumo era feito:
+        // o resumo é da conversa velha e não pode voltar por cima da nova.
+        if (state.history !== conversa) { sp.stop(); return; }
+        state.memoria = nova;
         sp.stop();
         const e = memoria.economia(state.memoria, state.history);
-        if (e.poupado > 0) console.log(c.dim(`  ⎿ conversa resumida · ${e.cheio} → ${e.enxuto} tokens por pedido`));
+        if (!silencioso && e.poupado > 0) console.log(c.dim(`  ⎿ conversa resumida · ${e.cheio} → ${e.enxuto} tokens por pedido`));
     } catch {
         sp.stop();   // resumo é economia, não requisito: falhou, segue a vida
     }
 }
 
+/* ── O RESUMO DE CADA RODADA ─────────────────────────────────────────────
+ * "Gere um resumo a cada mensagem, pra na próxima ela ler só esse resumo."
+ * O resumo começa assim que a resposta termina, atrás, sem segurar o prompt —
+ * a pessoa lê a resposta enquanto ele é feito. O pedido seguinte espera por
+ * ele (com teto: rede lenta não pode travar a conversa), e aí leva só o
+ * resumo, não a conversa inteira. Ver lib/memoria-conversa.js. */
+function resumirDepois() {
+    const anterior = state.resumindo || Promise.resolve();
+    const atual = anterior.then(() => comprimirConversa(false, { silencioso: true })).catch(() => {});
+    state.resumindo = atual;
+    atual.then(() => { if (state.resumindo === atual) state.resumindo = null; });
+}
+
+async function esperarResumo(tetoMs = 15000) {
+    if (!state.resumindo) return;
+    await Promise.race([state.resumindo, new Promise((ok) => setTimeout(ok, tetoMs))]);
+}
+
+/* A linha que vai junto do resumo: em que projeto se está. É o que faz
+   "continua o jogo" e "muda a cor" caírem no mesmo projeto em vez de inventar
+   outro. */
+function contextoDoProjeto() {
+    if (!state.currentProject) return '';
+    return `Projeto atual: ${state.currentProject} (pasta ${shortPath(projectDir())}). `
+        + 'Pedidos como "continua", "edita", "muda", "melhora" ou "isso" são sobre ELE: '
+        + 'trabalhe nos arquivos que já existem lá, não crie outro projeto.';
+}
+
 // O chat também precisa parar no Esc Esc. Sem isto o texto continuava saindo
 // na tela depois de o usuário ter mandado parar.
 let chatEmVoo = null;
@@ -1027,7 +1144,7 @@ async function runChat(promptForModel, userTextForMemory) {
         try {
             await api.requestChat(state.config.server, {
                 prompt: promptForModel,
-                history: memoria.paraEnviar(state.memoria, state.history),
+                history: memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()),
                 model: state.config.model,
                 token: state.config.token,
                 sinal: chatEmVoo.signal,
@@ -1057,6 +1174,7 @@ async function runChat(promptForModel, userTextForMemory) {
     if (text) {
         state.history.push({ role: 'user', content: userTextForMemory });
         state.history.push({ role: 'assistant', content: text });
+        resumirDepois();
         state.lastResponse = text;
         cfg.appendHistory({ mode: 'chat', prompt: userTextForMemory });
         state.gravador.turno(userTextForMemory, text, { modo: 'chat' });
@@ -1121,6 +1239,7 @@ async function rodarBash(text) {
         role: 'assistant',
         content: `Saída (código ${r.code ?? 0}):\n${saida.slice(0, 4000) || '(vazia)'}`,
     });
+    resumirDepois();
 }
 
 /* ── OS NOMES ANTIGOS ────────────────────────────────────────────────────
@@ -1179,9 +1298,7 @@ async function handleSlash(text) {
                 break;
             }
             const dir = cfg.createProjectDir(rest);
-            state.workDir = dir;
-            state.currentProject = path.basename(dir);
-            state.workDirOrigem = 'projeto';
+            entrarNoProjeto(dir, 'projeto');
             console.log(c.ok(`Projeto: ${state.currentProject}`) + c.muted(`  (${dir})`));
             refreshPrompt();
             break;
@@ -1232,9 +1349,7 @@ async function handleSlash(text) {
                 }
             }
 
-            state.workDir = alvo;
-            state.currentProject = path.basename(alvo);
-            state.workDirOrigem = '/dir';
+            entrarNoProjeto(alvo, '/dir');
             const quantos = (() => { try { return fs.readdirSync(alvo).length; } catch { return 0; } })();
             console.log(c.ok(`  Trabalhando em ${shortPath(alvo)}`) + c.muted(`  (${quantos} ${quantos === 1 ? 'item' : 'itens'})`));
             refreshPrompt();
@@ -1573,17 +1688,21 @@ async function handleSlash(text) {
                    porque resposta boa de ler é ruim de ouvir — o trabalho é o
                    mesmo, o jeito de contar é que muda. */
                 pensar: async (texto) => {
+                    // Mesma memória do terminal: espera o resumo da rodada
+                    // anterior e leva só ele, com o projeto atual.
+                    await esperarResumo();
                     const plan = prepararPasta(texto);
-                    const resultado = await runAct(`${vozModo.COMO_FALAR}\n\nPEDIDO: ${texto}`, {
+                    const resultado = await runAct(texto, {
+                        instrucao: vozModo.COMO_FALAR,
                         server: state.config.server,
                         model: state.config.model,
                         effort: state.config.effort,
                         token: state.config.token,
-                        history: memoria.paraEnviar(state.memoria, state.history),
+                        history: memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()),
                         projectDir: plan.dir,
                         projectName: plan.name || state.currentProject,
                         ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
-                        autorizar: autorizarControle,
+                        autorizar: autorizarPorVoz,
                         controle: state.controle,
                     });
                     const resposta = (resultado.assistantMessage && resultado.assistantMessage.content) || '';
@@ -1591,6 +1710,7 @@ async function handleSlash(text) {
                     // continuar digitando não pode começar do zero.
                     state.history.push({ role: 'user', content: texto });
                     state.history.push({ role: 'assistant', content: resposta });
+                    resumirDepois();
                     const balanco = registro.resumo(resultado.registro, { colunas: process.stdout.columns || 80 });
                     if (balanco) console.log(balanco);
                     return resposta;
@@ -1945,6 +2065,14 @@ async function main() {
     state.workDir = cfg.ROOT_DIR;
     state.currentProject = null;
     state.workDirOrigem = 'padrao';
+    // O projeto em que se estava na última sessão (até uma semana atrás): o
+    // "continua o jogo" de amanhã cai nele, e não num projeto novo.
+    const lembrado = cfg.projetoLembrado();
+    if (lembrado && pastaSegura(lembrado.dir)) {
+        state.workDir = lembrado.dir;
+        state.currentProject = path.basename(lembrado.dir);
+        state.workDirOrigem = lembrado.origem === '/dir' ? '/dir' : 'projeto';
+    }
 
     // Modo guardado entre sessões. O padrão é auto: sem ele, um "oi" gasta o
     // mesmo que uma refatoração.

package/lib/act.js

@@ -454,6 +454,12 @@ async function runAct(userPrompt, opts) {
            `test/repeticao.js` e `test/continuar.js` teriam de falar com a
            internet para verificar o loop do agente. */
         motor = api,
+        /* Instrução de FORMA que vai junto do pedido mas não É o pedido — a
+           do modo voz ("responda em três frases faladas"). Ela chega ao
+           modelo; a memória e o histórico guardam só o que a pessoa disse.
+           Antes ela ia colada no texto, e a memória do projeto enchia de
+           "[MODO VOZ] A sua resposta vai ser lida em voz alta…". */
+        instrucao = '',
     } = opts || {};
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
@@ -463,6 +469,16 @@ async function runAct(userPrompt, opts) {
     let criarPasta = ensureWorkDir || null;
     let pastaAtual = projectDir;      // onde as tools agem AGORA
     let temPasta = !criarPasta;       // já é a pasta definitiva?
+    /* Cria a pasta do projeto pendente, uma vez. Chamado antes de qualquer
+       ferramenta que faz código (ver `criaProjeto` no catálogo) — e ANTES do
+       subagente e do pipeline, que senão escreviam na raiz de ~/primocode. */
+    const garantirPasta = () => {
+        if (!criarPasta) return;
+        const nova = criarPasta();
+        if (nova) pastaAtual = nova;
+        criarPasta = null;
+        temPasta = true;
+    };
     const falhasPendentes = [];
     let tentativasDeEncerrar = 0;
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
@@ -492,6 +508,7 @@ async function runAct(userPrompt, opts) {
     if (!subagent) {
         const comSkills = skills.montar(userPrompt);
         pedido = comSkills.texto;
+        if (instrucao) pedido = `${instrucao}\n\nPEDIDO: ${pedido}`;
         if (comSkills.skills.length) {
             fala.pensamento(`seguindo: ${comSkills.skills.map((s) => s.titulo).join(', ')}`, profundidade);
         }
@@ -627,7 +644,7 @@ async function runAct(userPrompt, opts) {
 
         emVoo = new AbortController();
         try {
-            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir, projectName, subagent, sinal: emVoo.signal }, (evt) => {
+            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
                 if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {
@@ -843,6 +860,7 @@ async function runAct(userPrompt, opts) {
         // sinal de decomposição ruim, e o excedente roda em série mesmo.
         const spawns = toolCalls.filter((tc) => tc.name === 'spawn_agent');
         const resultadosSpawn = new Map();
+        if (spawns.length && !PARAR) garantirPasta();
         if (spawns.length > 1 && !PARAR) {
             const juntos = spawns.slice(0, 4);
             fala.paralelo(juntos.length, profundidade);
@@ -906,6 +924,7 @@ async function runAct(userPrompt, opts) {
                esquecer de passar o token ou a pasta. */
             if (tc.name === 'construir_app') {
                 algoRodou = true;
+                garantirPasta();
                 fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarPipeline(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, livro, autorizar, controle: portaoControle,
@@ -928,12 +947,7 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
-            if (criarPasta && catalogo.escreveArquivo(tc.name)) {
-                const nova = criarPasta();
-                if (nova) pastaAtual = nova;
-                criarPasta = null;
-                temPasta = true;
-            }
+            if (criarPasta && catalogo.criaProjeto(tc.name, tc.arguments)) garantirPasta();
 
             if (tc.name === 'pesquisar_referencia' && pesquisasSecas >= 3) {
                 voltasEmFalso++;
@@ -1209,9 +1223,13 @@ async function rodarPipeline(args, ctx) {
     const path = require('path');
     const pedido = args.pedido || args.prompt || '';
     const base = projectDir || cfg.ROOT_DIR;
+    /* Dentro de um projeto, o app é montado NA pasta dele. A subpasta com
+       nome derivado do pedido só vale na raiz: era ela que fazia o app nascer
+       num lugar que a conversa nunca mais achava. */
+    const naRaiz = path.resolve(base) === path.resolve(cfg.ROOT_DIR);
     const pasta = args.pasta
         ? path.resolve(base, args.pasta)
-        : pipeline.pastaPara(pedido, base);
+        : (naRaiz ? pipeline.pastaPara(pedido, base) : base);
 
     const correr = async (prompt, rotulo) => {
         if (PARAR) return '';

package/lib/catalogo.js

@@ -206,6 +206,25 @@ function escreveArquivo(tool) {
     return ESCREVEM.has(tool);
 }
 
+/* ── O QUE FAZ NASCER UMA PASTA DE PROJETO ──────────────────────────────
+ * "Ela deve saber quando criar pasta do projeto e quando não criar — só vai
+ * criar quando fizer código." `escreve` era largo demais para isso: um print
+ * de tela, uma narração do estúdio e um vídeo também escrevem arquivo, e cada
+ * um deles criava um projeto com o nome da frase. Aqui só o que é CÓDIGO:
+ * escrever ou editar arquivo, montar um app, delegar a um especialista, e o
+ * comando de terminal que cria arquivo (o agente que faz `npm create` ou
+ * `mkdir` estava pondo o projeto solto na raiz de ~/primocode). */
+const CRIAM_PROJETO = new Set(['write_file', 'edit_file', 'multi_edit', 'construir_app', 'spawn_agent']);
+const SHELL_QUE_CRIA = /\b(mkdir|touch|git\s+clone|npm\s+(init|create)|npx\s+(create-|degit|nuxi\s+init)|yarn\s+create|pnpm\s+(create|dlx\s+create-)|bun\s+create|cargo\s+(new|init)|python3?\s+-m\s+venv|django-admin\s+startproject|rails\s+new|flutter\s+create|dotnet\s+new|composer\s+create-project|expo\s+init)\b|(^|[^<>&|0-9])>>?\s*[\w./~-]/;
+
+function criaProjeto(tool, args) {
+    if (CRIAM_PROJETO.has(tool)) return true;
+    if (tool === 'run_shell' || tool === 'run_in_new_terminal') {
+        return SHELL_QUE_CRIA.test(String((args && (args.command || args.comando)) || ''));
+    }
+    return false;
+}
+
 
 /**
  * As ferramentas de nome mais parecido com o que foi chamado.
@@ -244,5 +263,5 @@ function parecidasCom(nome) {
     return pontos.slice(0, 6).map((x) => x.t);
 }
 
-module.exports = {
+module.exports = { criaProjeto,
     parecidasCom, GRUPOS, TODAS, ESCREVEM, escreveArquivo };

package/lib/config.js

@@ -21,6 +21,7 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const HISTORY_FILE = path.join(CONFIG_DIR, 'history.jsonl');
 const CONTA_FILE = path.join(CONFIG_DIR, 'conta.json');
 const GENERAL_MEMORY = path.join(ROOT_DIR, 'memory-geral.md');
+const PROJETO_ATIVO_FILE = path.join(CONFIG_DIR, 'projeto-ativo.json');
 
 /* O token da conta, lido DIRETO do arquivo.
  *
@@ -309,7 +310,35 @@ function appendHistory(entry) {
     } catch {}
 }
 
+/* ── O PROJETO EM QUE SE ESTAVA ─────────────────────────────────────────
+ * "Eu peço o jogo de carro, depois peço pra editar ou continuar, e ele cria
+ * outro projeto." Nada sobrevivia entre uma sessão e outra: cada abertura
+ * começava em ~/primocode, e o "continua" virava projeto novo. Agora o projeto
+ * ativo fica guardado aqui, num arquivo só dele (a config tem lista fechada de
+ * campos), e a próxima sessão continua nele. Vale por uma semana: depois
+ * disso, abrir o PrimoCode e cair num projeto esquecido seria a surpresa. */
+function lembrarProjeto(dir, origem = 'projeto') {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(PROJETO_ATIVO_FILE, JSON.stringify({ dir, origem, quando: Date.now() }, null, 2), 'utf-8');
+    } catch { /* lembrar é conveniência: falhou, a sessão segue igual */ }
+}
+
+function projetoLembrado(maxDias = 7) {
+    try {
+        const j = JSON.parse(fs.readFileSync(PROJETO_ATIVO_FILE, 'utf-8'));
+        if (!j || !j.dir || !fs.existsSync(j.dir) || !fs.statSync(j.dir).isDirectory()) return null;
+        if (Date.now() - Number(j.quando || 0) > maxDias * 86400000) return null;
+        return { dir: j.dir, origem: j.origem || 'projeto' };
+    } catch { return null; }
+}
+
+function esquecerProjeto() {
+    try { fs.rmSync(PROJETO_ATIVO_FILE, { force: true }); } catch { /* nada a esquecer */ }
+}
+
 module.exports = {
+    lembrarProjeto, projetoLembrado, esquecerProjeto, PROJETO_ATIVO_FILE,
     loadConfig, saveConfig, appendHistory,
     CONFIG_DIR, CONFIG_FILE, HISTORY_FILE, ROOT_DIR, GENERAL_MEMORY,
     ensureStructure, slugify, stripAccents,