primocode 10.5.0 → 10.7.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.4.7
+# PrimoCode v10.7.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 v10.4.7
+ ▐▛███▜▌   Primo Code v10.7.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -21,11 +21,14 @@ const api = require('../lib/api');
 const tools = require('../lib/tools');
 const cfg = require('../lib/config');
 const nomeProjeto = require('../lib/nome-projeto');
+const { nomeCurto } = require('../lib/nome-curto');
 const provedorLocal = require('../lib/local/provedor');
 const { runAct, interromper, ehTetoDeToken, ehTransitorio, esperaDoErro, mandarDuranteATarefa, sobrasDaCaixa } = require('../lib/act');
 const fala = require('../lib/fala');
 const boasVindas = require('../lib/boas-vindas');
 const pasta = require('../lib/pasta');
+const outraPasta = require('../lib/outra-pasta');
+const agentsMd = require('../lib/agents-md');
 const catalogo = require('../lib/catalogo');
 const effort = require('../lib/effort');
 const memoria = require('../lib/memoria-conversa');
@@ -793,32 +796,82 @@ function projectDir() {
 // ── Envio ──────────────────────────────────────────────────────────────
 
 /**
- * Falou de uma pasta? Ele procura no computador e muda para ela.
+ * Falou de OUTRA pasta? Ele LÊ lá sem pedir, e só TROCA com o seu sim.
  *
- * Conservador de propósito: só troca quando acha UMA pasta. Com mais de uma,
- * lista e espera o /dir — heurística não deve escolher onde o agente escreve.
+ * "Quando eu perguntar de algo de outra pasta, ela vai procurar lá; e se ela
+ * está aberta numa pasta e eu trabalho em outra, ela muda — com permissão."
+ * A pasta citada (caminho, "pasta X", ou o nome de um projeto/pasta recente)
+ * fica liberada para leitura (lib/tools.js). A troca pergunta, Enter é NÃO.
+ *
+ * Devolve a nota para o modelo quando a pessoa ficou onde estava — é ela que
+ * diz ao agente que pode procurar lá. Com mais de uma pasta do mesmo nome,
+ * lista e espera o /dir: heurística não escolhe onde o agente escreve.
  */
-function talvezTrocarDePasta(userText) {
-    const candidato = pasta.detectarPasta(userText);
-    if (!candidato) return;
-
-    const achado = pasta.resolverPasta(candidato, { raiz: cfg.ROOT_DIR, cwd: CWD_INICIAL });
-    if (!achado) return;   // não existe no disco: segue onde está, sem barulho
-
-    if (achado.ambiguo) {
-        console.log(c.warn(`  Achei ${achado.ambiguo.length} pastas chamadas "${candidato}":`));
-        achado.ambiguo.forEach((a) => console.log(`   ${c.dim('·')} ${c.white(shortPath(a.caminho))}`));
+async function talvezTrocarDePasta(userText) {
+    const r = outraPasta.detectar(userText, {
+        conhecidas: outraPasta.conhecidas({ raiz: cfg.ROOT_DIR, recentes: cfg.pastasRecentes() }),
+        atual: projectDir(),
+        resolver: (cand) => pasta.resolverPasta(cand, { raiz: cfg.ROOT_DIR, cwd: CWD_INICIAL }),
+    });
+    if (r.ambiguo) {
+        console.log(c.warn(`  Achei ${r.ambiguo.length} pastas chamadas "${r.candidato}":`));
+        r.ambiguo.forEach((a) => console.log(`   ${c.dim('·')} ${c.white(shortPath(a.caminho))}`));
         console.log(c.dim('  Escolha com /dir <caminho>.'));
-        return;
+        return '';
     }
-    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
+    const alvo = (r.pastas || []).find((p) => pastaSegura(p.caminho));
+    if (!alvo) return '';   // home ou raiz: só por /dir explícito
+
+    tools.liberarLeitura(alvo.caminho);
+
+    /* No pedido único (`primocode "crie x na pasta loja"`) não há a quem
+       perguntar — e a pasta veio escrita no próprio comando, com marca
+       ("pasta", caminho). Aí vale o que ele sempre fez: troca. Nome solto
+       ("olha o landing-padaria") nunca troca sem pergunta. */
+    if (state.semTerminal) {
+        if (alvo.como !== 'caminho') return outraPasta.notaDeConsulta(alvo.caminho, projectDir());
+        entrarNoProjeto(alvo.caminho, 'detectada');
+        return '';
+    }
+    console.log(c.dim(`  ⎿ você citou ${shortPath(alvo.caminho)} — posso ler lá daqui mesmo`));
+    if (!(await perguntarTroca(alvo.caminho))) return outraPasta.notaDeConsulta(alvo.caminho, projectDir());
+    trocarPara(alvo.caminho, 'detectada', `você falou "${alvo.nome}"`);
+    return '';
+}
+
+/* A pergunta da troca. Enter sozinho é NÃO: trocar muda onde os arquivos
+   nascem, e o padrão de quem apertou Enter sem ler não pode ser esse. */
+async function perguntarTroca(caminho, motivo = '') {
+    if (motivo) console.log('  ' + c.muted(motivo));
+    const dito = String(await ask(`${c.brand('?')} Trabalhar em ${c.white(shortPath(caminho))} a partir de agora? ${c.muted('(s/N)')} `))
+        .trim().toLowerCase().replace(/[.!?,;:…]+/g, ' ').trim();
+    if (!process.stdin.isTTY) process.stdout.write('\n');
+    return /^(s|sim|y|yes|pode|ok|claro|muda|troca)\b/.test(dito);
+}
 
-    entrarNoProjeto(achado.caminho, 'detectada');
-    console.log(c.ok(`  Trabalhando em ${shortPath(achado.caminho)}`) + c.dim(`  (você falou "${candidato}")`));
+/* Entra na pasta e avisa. A memória dela (AGENTS.md) entra no próximo
+   pedido pelo buildMemoryContext, porque ainda não está no resumo. */
+function trocarPara(caminho, origem, porque) {
+    entrarNoProjeto(caminho, origem);
+    const tem = agentsMd.ler(caminho) ? ' · com memória das sessões anteriores' : '';
+    console.log(c.ok(`  Trabalhando em ${shortPath(caminho)}`) + c.dim(`  (${porque}${tem})`));
     refreshPrompt();
 }
 
+/* O mudar_pasta do modelo chega aqui (lib/outra-pasta.js → pedirTroca). */
+async function mudarPastaPeloAgente({ caminho, motivo }) {
+    if (state.semTerminal) return { ok: false, error: 'sem terminal para o usuário responder.' };
+    console.log('');
+    console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white('O Primo quer trabalhar em outra pasta.')));
+    if (!(await perguntarTroca(caminho, motivo ? `Motivo: ${motivo}` : ''))) {
+        console.log('  ' + c.muted('Fica onde está.') + c.dim(' Ele ainda pode ler a outra pasta.'));
+        tools.liberarLeitura(caminho);
+        return { ok: false };
+    }
+    trocarPara(caminho, 'detectada', 'você autorizou');
+    return { ok: true, caminho, memoria: agentsMd.ler(caminho) || undefined };
+}
+
 /**
  * Decide, de uma vez, onde este pedido vai trabalhar.
  *
@@ -827,10 +880,10 @@ function talvezTrocarDePasta(userText) {
  * `primocode "crie x na pasta loja"` ignorava a pasta e criava projeto novo.
  * Duas cópias da mesma decisão significam que uma delas está errada.
  */
-function prepararPasta(userText) {
+async function prepararPasta(userText) {
     // A pasta é decidida ANTES de o agente começar. Trocar no meio faria as
     // primeiras tools agirem num lugar e as seguintes em outro.
-    talvezTrocarDePasta(userText);
+    const notaOutraPasta = await talvezTrocarDePasta(userText);
 
     const plan = planWorkDir(userText);
     batizarDepois(plan, userText);
@@ -843,6 +896,7 @@ function prepararPasta(userText) {
         console.log(c.ok(`  Continuando em ${state.currentProject}`) + c.muted(`  (${shortPath(plan.dir)})`));
         refreshPrompt();
     }
+    plan.notaOutraPasta = notaOutraPasta;
     return plan;
 }
 
@@ -1133,7 +1187,7 @@ async function enviarPedido(userText) {
         // mídia inventada, limite estourado) para chegar no mesmo lugar.
         if (await baixarCriacaoDireto(userText)) { refreshPrompt(); return; }
 
-        const plan = prepararPasta(userText);
+        const plan = await prepararPasta(userText);
 
         // O Chrome só aparece na tela quando o pedido é de navegador (lib/browser.js, definirVisivel).
         require('../lib/browser.js').definirVisivel(querNavegador(userText));
@@ -1213,15 +1267,22 @@ async function enviarPedido(userText) {
                 // No pedido único (`primo "…"`) não há ninguém para responder:
                 // sem `autorizar`, o que pede licença é recusado (lib/perigo.js).
                 autorizar: state.semTerminal ? undefined : autorizarControle,
+                // A memória do AGENTS.md só vai se o resumo ainda não a carrega.
+                memoriaDaPasta: !memoria.jaDobrou(state.memoria, plan.dir),
+                mudarPasta: state.semTerminal ? null : mudarPastaPeloAgente,
                 controle: state.controle,
                 permissoes: state.config.permissoes,
                 // 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 : '',
-                    i === 0 ? require('../lib/estudio/referencias.js').instrucao() : ''].filter(Boolean).join('\n\n'),
+                    i === 0 ? require('../lib/estudio/referencias.js').instrucao() : '',
+                    i === 0 ? plan.notaOutraPasta || '' : ''].filter(Boolean).join('\n\n'),
             });
 
             r = await rodarPasso();
+            // O mudar_pasta trocou no meio: os passos seguintes seguem lá.
+            if (r && r.pasta && path.resolve(r.pasta) !== path.resolve(plan.dir)) { plan.dir = r.pasta; plan.pending = false; }
+            if (r && r.estudio) state.estudioAtivo = r.estudio;
             /* Passo que parou no meio NÃO devolve a tarefa para a pessoa
                dividir. Se ele já tinha feito alguma coisa (arquivo, comando),
                o próprio CLI pede a continuação — com a lista do que já existe
@@ -1423,6 +1484,14 @@ async function comprimirConversa(forcado = false, { silencioso = false } = {}) {
     const sp = silencioso ? { stop() {} } : new Spinner('resumindo a conversa').start();
     try {
         const conversa = state.history;
+        const dir = projectDir();
+        /* A memória que o AGENTS.md desta pasta já tinha entra no resumo
+           (uma vez por pasta): sem isto a primeira resposta de uma sessão nova
+           reescreveria o AGENTS.md só com ela, e o "de onde parei" de ontem
+           sumia. */
+        if (!memoria.jaDobrou(state.memoria, dir) && !(state.memoria.semente && state.memoria.semente.pasta === dir)) {
+            state.memoria = memoria.semear(state.memoria, dir, agentsMd.ler(dir));
+        }
         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));
@@ -1431,6 +1500,7 @@ async function comprimirConversa(forcado = false, { silencioso = false } = {}) {
         if (state.history !== conversa) { sp.stop(); return; }
         state.memoria = nova;
         sp.stop();
+        gravarMemoriaDaPasta(dir);
         const e = memoria.economia(state.memoria, state.history);
         if (!silencioso && e.poupado > 0) console.log(c.dim(`  ⎿ conversa resumida · ${e.cheio} → ${e.enxuto} tokens por pedido`));
     } catch {
@@ -1451,6 +1521,24 @@ function resumirDepois() {
     atual.then(() => { if (state.resumindo === atual) state.resumindo = null; });
 }
 
+/* ── O AGENTS.md DE CADA PASTA ───────────────────────────────────────────
+ * "Eu preciso de um AGENTS.md com a memória da conversa em cada pasta."
+ * O resumo da conversa vai para o AGENTS.md da pasta de trabalho (só o bloco
+ * do PrimoCode; o resto do arquivo é da pessoa — lib/agents-md.js), e para a
+ * pasta do projeto do Estúdio em que se mexeu, se houver. A raiz
+ * ~/primocode fica de fora: é o corredor, não um projeto. */
+function gravarMemoriaDaPasta(dir = projectDir()) {
+    const resumo = state.memoria && state.memoria.resumo;
+    if (!resumo) return;
+    try { agentsMd.gravar(dir, resumo, { raiz: cfg.ROOT_DIR }); } catch { /* memória é conveniência */ }
+    if (state.estudioAtivo) {
+        try {
+            const p = require('../lib/estudio/projeto.js').ler(state.estudioAtivo);
+            if (p) agentsMd.gravar(p.pasta, resumo, { titulo: p.titulo });
+        } catch { /* projeto sumiu */ }
+    }
+}
+
 async function esperarResumo(tetoMs = 6000) {
     if (!state.resumindo) return;
     await Promise.race([state.resumindo, new Promise((ok) => setTimeout(ok, tetoMs))]);
@@ -1495,7 +1583,11 @@ function contextoDoProjeto() {
    instruções do projeto entram. Sem isto o PRIMO.md valeria para o agente e
    seria ignorado quando o modo auto manda o pedido para a conversa. */
 function comInstrucoes(history) {
-    const texto = mencoesLib.instrucoesDoProjeto(state.currentProject || state.workDir ? projectDir() : null);
+    const dir = state.currentProject || state.workDir ? projectDir() : null;
+    let texto = mencoesLib.instrucoesDoProjeto(dir);
+    // A memória do AGENTS.md também vale no chat, enquanto o resumo não a tem.
+    const daPasta = dir && !memoria.jaDobrou(state.memoria, dir) ? agentsMd.ler(dir) : '';
+    if (daPasta) texto = [texto, `[AGENTS.md — memória desta pasta: de onde a conversa parou]\n${daPasta}`].filter(Boolean).join('\n\n');
     return texto ? [{ role: 'system', content: texto }, ...history] : history;
 }
 
@@ -2004,7 +2096,8 @@ async function handleSlash(text) {
             sp.stop();
             const nomeNovo = extra.nomeDoNovo({
                 descricao: rest, nomes, sugerido, derivar: deriveProjectName,
-                slugify: cfg.slugify, semColisao: nomeProjeto.semColisao,
+                // A régua curta (lib/nome-curto.js) também no /novo.
+                slugify: (t) => nomeCurto(t) || cfg.slugify(t), semColisao: nomeProjeto.semColisao,
             });
             const dir = cfg.createProjectDir(nomeNovo);
             entrarNoProjeto(dir, 'projeto');

package/lib/act.js

@@ -26,6 +26,8 @@ const skills = require('./skills');
 const checkpoint = require('./checkpoint');
 const tempos = require('./tempos');
 const preLeitura = require('./pre-leitura');
+const travado = require('./travado');
+const auditoria = require('./auditoria');
 
 // 40, não 15: com o freio de repetição (repeticao.js) e o de rodada parada,
 // volta a mais não é volta em círculo — é trabalho. Quinze acabavam no meio
@@ -41,7 +43,7 @@ const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
 // As leituras que, repetidas sem mudança no meio, devolvem o guardado.
 const RELEITURA = new Set(['read_file', 'list_dir']);
 /* O que só lê: pode rodar junto com as outras leituras da mesma rodada. */
-const SO_LEITURA = new Set(['read_file', 'list_dir', 'glob', 'grep', 'pesquisar_referencia', 'estudio_site']);
+const SO_LEITURA = new Set(['read_file', 'list_dir', 'glob', 'grep', 'pesquisar_referencia', 'estudio_site', 'mcp_procurar']);
 const ehLeitura = (tc) => SO_LEITURA.has(tc.name)
     || (tc.name === 'run_shell' && /^\s*primocode\s+(skill|mcp\s+list|video\s+(help|get_timeline|get_transcript))\b/.test(String((tc.arguments && tc.arguments.command) || '')));
 
@@ -275,6 +277,17 @@ function logResult(kind, result, profundidade) {
             }
             return;
         }
+        case 'mcp_procurar': {
+            console.log(p + c.muted(`${(result.resultados || []).length} MCP para "${result.busca}"`));
+            for (const r of (result.resultados || []).slice(0, 4)) console.log(p + c.dim(`${r.nome} · ${r.descricao}`.slice(0, 110)));
+            return;
+        }
+        case 'mcp_conectar':
+            console.log(p + c.ok('conectado') + c.muted(` · ${result.servidor} · ${(result.ferramentas || []).length} tools`));
+            return;
+        case 'mcp_usar':
+            console.log(p + c.muted(`${result.servidor}.${result.ferramenta} · ${String(result.resultado || '').length} caracteres`));
+            return;
         case 'desktop_windows': {
             console.log(p + c.muted(`${result.total} janela${result.total === 1 ? '' : 's'}`));
             for (const j of (result.janelas || []).slice(0, 5)) console.log(p + c.dim(`${j.app ? j.app + ' · ' : ''}${j.titulo}`.slice(0, 120)));
@@ -645,6 +658,11 @@ function historicoEnxuto(history) {
  * vêm do que o opencode e o Codex põem nos prompts deles para o modelo não
  * reler o que fez; entram em TODO pedido, curtas, porque o plano conta token.
  * A conferência de verdade é nossa (a página aberta no Chrome escondido). */
+/* MCP primeiro, mouse por último: vale no modo local e no subagente, que não
+   recebem o prompt do servidor. */
+const FERRAMENTA_CERTA = '- FERRAMENTA CERTA: para agir num serviço ou app, use primeiro um MCP (veja [mcp]). '
+    + 'Sem MCP: mcp_procurar → mcp_conectar → mcp_usar. Mouse/desktop_* só quando não houver MCP, API ou CLI.';
+
 const RITMO = '[ritmo]\n'
     + '- O resultado de write_file/edit_file é a verdade. Não releia um arquivo que você acabou de escrever para conferir (nem com cat/sed/head): a conferência é do PrimoCode.\n'
     + '- Várias ações independentes vão na MESMA resposta (ex.: escrever index.html, style.css e script.js juntos).\n'
@@ -653,24 +671,34 @@ const RITMO = '[ritmo]\n'
     + '- VOCÊ DECIDE O CAMINHO. Pedido simples: faça direto. Pedido grande com partes independentes: write_todos com as partes, '
     + 'depois spawn_agent — um por parte, até 8 NA MESMA resposta (rodam juntos), cada um com o especialista e tudo que ele precisa saber. '
     + 'Cada um volta com uma ENTREGA: confira; o que falhou volta para conserto; a parte que depende de outra recebe a entrega dela no prompt.\n'
-    + '- Antes de dizer pronto, PROVE: rode o teste ou o comando, abra o resultado, olhe a imagem. Sem prova, não está pronto.';
+    + '- Antes de dizer pronto, PROVE: rode o teste ou o comando, abra o resultado, olhe a imagem. Sem prova, não está pronto.\n'
+    + FERRAMENTA_CERTA;
 
 /* O ritmo do subagente: o mesmo, sem a parte de orquestrar (ele não abre outro agente). */
 const RITMO_AGENTE = '[ritmo]\n'
     + '- O resultado de write_file/edit_file é a verdade. Não releia o que acabou de escrever.\n'
     + '- Leia um arquivo INTEIRO uma vez (read_file sem offset). Não leia aos pedaços, não leia de novo o que não mudou.\n'
     + '- Várias ações independentes na MESMA resposta.\n'
-    + '- Faça o que a sua parte pede, prove (teste ou comando) e chame finish. Polimento além do pedido não é sua parte.';
+    + '- Faça o que a sua parte pede, prove (teste ou comando) e chame finish. Polimento além do pedido não é sua parte.\n'
+    + FERRAMENTA_CERTA;
 
 /* `pedido` é opcional: com ele, o arquivo citado no pedido é o primeiro a
    entrar já lido (ver lib/pre-leitura.js). */
-function buildMemoryContext(projectDir, projectName, pedido = '') {
+function buildMemoryContext(projectDir, projectName, pedido = '', { memoriaDaPasta = true } = {}) {
     const parts = [];
     // As instruções vêm primeiro: são regra de quem manda no projeto, e a
     // memória é o que o agente anotou. Entram aqui (e não no bin) para valer
     // igual no terminal, no modo voz e em cada passo de um plano.
     const instrucoes = require('./mencoes.js').instrucoesDoProjeto(projectDir);
     if (instrucoes) parts.push(instrucoes);
+    /* A conversa das sessões anteriores NESTA pasta (lib/agents-md.js). É o
+       que faz a sessão de amanhã começar de onde a de hoje parou. Quando o
+       resumo da conversa já a carrega (`memoriaDaPasta: false`, quem sabe é o
+       bin), ela não vem de novo. */
+    if (memoriaDaPasta) {
+        const daPasta = require('./agents-md.js').ler(projectDir);
+        if (daPasta) parts.push(`[AGENTS.md — memória desta pasta: de onde a conversa parou]\n${daPasta}`);
+    }
     const geral = cfg.readGeneralMemory();
     if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
     const projeto = cfg.readProjectMemory(projectDir);
@@ -693,6 +721,14 @@ async function runAct(userPrompt, opts) {
     const {
         server, model, token, history, projectDir, projectName,
         ensureWorkDir, profundidade = 0, subagent = false, effort,
+        /* A memória do AGENTS.md entra no contexto? O bin diz não quando o
+           resumo da conversa já a dobrou (lib/memoria-conversa.js). */
+        memoriaDaPasta = true,
+        /* Quem troca a pasta de trabalho quando o modelo chama mudar_pasta:
+           async ({ caminho, motivo }) → { ok, caminho, memoria?, error? }.
+           Vem do bin, porque é lá que se PERGUNTA ao usuário — sem ele (pipe,
+           subagente) a troca é recusada. */
+        mudarPasta = null,
         /* Quem responde ao pedido de controle do computador, e o estado da
            resposta. Vêm de fora porque quem sabe perguntar é o terminal, e
            quem sabe lembrar é a SESSÃO — um subagente não pode começar do
@@ -723,6 +759,8 @@ async function runAct(userPrompt, opts) {
            teste que troca o medidor não pode subir um Chrome de verdade. */
         aquecerPagina = opts && opts.medirPagina ? null
             : () => require('./browser.js').aquecerRevisor(),
+        /* Quem é este agente no livro de ações (auditoria.js). */
+        rotulo = subagent ? 'subagente' : 'principal',
     } = opts || {};
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
@@ -731,6 +769,7 @@ async function runAct(userPrompt, opts) {
     // nada. Quem decide é o catálogo: `escreve: true`.
     let criarPasta = ensureWorkDir || null;
     let pastaAtual = projectDir;      // onde as tools agem AGORA
+    let estudioDaTarefa = null;       // o projeto do Estúdio desta tarefa, se houver
     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
@@ -783,6 +822,17 @@ async function runAct(userPrompt, opts) {
         ? `${texto}\n\nAtenção: abri a página e ela ainda tem problema — ${avisoDaPagina.trim()}` : texto);
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
+    /* Andando em círculo? (lib/travado.js — o subagente de 01/10 que releu o
+       mesmo arquivo por uma hora). Empurra uma vez; na segunda, para. */
+    const circulo = travado.novo();
+    let paradoPorTravar = null;
+    /* Anota ANTES de agir (lib/auditoria.js): recusado também fica no livro. */
+    const anotar = (tc, decisao, motivo) => {
+        const id = auditoria.antes({ agente: rotulo, ferramenta: tc.name, args: tc.arguments, decisao, motivo });
+        const falhou = auditoria.problema();
+        if (falhou) console.log(c.warn(`⚠ ${falhou}`));
+        return id;
+    };
     // O que read_file/list_dir devolveram, pela chave da época (repeticao.js).
     const leiturasGuardadas = new Map();
     // O que ELE escreveu inteiro nesta tarefa, por caminho absoluto — para
@@ -834,7 +884,7 @@ async function runAct(userPrompt, opts) {
 
     const messages = [];
     if (!subagent) {
-        const memory = buildMemoryContext(projectDir, projectName, userPrompt);
+        const memory = buildMemoryContext(projectDir, projectName, userPrompt, { memoriaDaPasta });
         if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
         for (const m of historicoEnxuto(history)) messages.push(m);
     } else {
@@ -1253,11 +1303,12 @@ async function runAct(userPrompt, opts) {
         if (spawns.length > 1 && !PARAR) {
             const juntos = spawns.slice(0, 8);
             fala.paralelo(juntos.length, profundidade);
+            const ids = juntos.map((tc) => anotar(tc, 'permitida'));
             const rs = await Promise.all(juntos.map((tc) =>
                 runSubagent(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                 }).catch((e) => `Subagente falhou: ${e && e.message}`)));
-            juntos.forEach((tc, i) => resultadosSpawn.set(tc.id, rs[i]));
+            juntos.forEach((tc, i) => { resultadosSpawn.set(tc.id, rs[i]); auditoria.depois(ids[i], { ok: true }); });
         }
 
         /* LEITURAS JUNTAS. O RITMO pede ao modelo para juntar as ações
@@ -1265,10 +1316,23 @@ async function runAct(userPrompt, opts) {
            grep e uma pesquisa. Só que o laço abaixo rodava uma de cada vez, e
            a rodada custava a soma. O que só LÊ (não muda arquivo, tela nem
            conta) roda tudo de uma vez aqui; o laço usa o resultado pronto,
-           passando pelos mesmos freios de sempre (repetição, registro). */
+           passando pelos mesmos freios de sempre (repetição, registro).
+           Só entra no lote o que o laço NÃO vai recusar: a releitura, a
+           mesma leitura duas vezes na resposta e a pesquisa depois de três
+           secas ficam de fora. Senão rodavam aqui e o livro anotava
+           "recusada" para o que já tinha rodado. */
         const adiantadas = new Map();
-        const leituras = toolCalls.filter(ehLeitura);
+        const chavesDoLote = new Set();
+        const leituras = toolCalls.filter(ehLeitura).filter((tc) => {
+            if (tc.name === 'pesquisar_referencia' && pesquisasSecas >= 3) return false;
+            const { repetida, chave } = repeticao.espiar(jaChamado, tc.name, tc.arguments);
+            if (repetida || chavesDoLote.has(chave)) return false;
+            chavesDoLote.add(chave);
+            return true;
+        });
+        const idsAdiantados = new Map();
         if (leituras.length > 1 && !PARAR) {
+            leituras.slice(0, 8).forEach((tc) => idsAdiantados.set(tc.id, anotar(tc, 'permitida')));
             const rs = await Promise.all(leituras.slice(0, 8).map((tc) =>
                 tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api })
                     .catch((e) => ({ ok: false, error: e && e.message }))));
@@ -1276,6 +1340,7 @@ async function runAct(userPrompt, opts) {
             traco(`${adiantadas.size} leituras em paralelo`);
         }
 
+        let motivoTravou = null;
         for (const tc of toolCalls) {
             if (PARAR) break;
             if (tc.name === 'finish') {
@@ -1309,13 +1374,37 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
+            /* TROCAR DE PASTA mora aqui, e não no tools.execute: ela muda
+               `pastaAtual`, que é deste laço, e precisa de quem PERGUNTA ao
+               usuário (o bin). Sem a resposta dele, não troca. */
+            if (tc.name === 'mudar_pasta') {
+                algoRodou = true;
+                fala.acao(tc.name, tc.arguments, profundidade);
+                const idA = anotar(tc, 'permitida');
+                const r = await require('./outra-pasta.js').pedirTroca(tc.arguments || {}, {
+                    atual: pastaAtual, subagent, trocar: mudarPasta,
+                });
+                if (r.ok) {
+                    pastaAtual = r.caminho;
+                    criarPasta = null;
+                    temPasta = true;
+                }
+                logResult(tc.name, r, profundidade);
+                auditoria.depois(idA, r);
+                repeticao.executou(jaChamado, tc.name, tc.arguments);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
+                continue;
+            }
+
             if (tc.name === 'spawn_agent') {
                 algoRodou = true;
+                const idA = resultadosSpawn.has(tc.id) ? null : anotar(tc, 'permitida');
                 const r = resultadosSpawn.has(tc.id)
                     ? resultadosSpawn.get(tc.id)
                     : await runSubagent(tc.arguments || {}, {
                         server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                     });
+                if (idA) auditoria.depois(idA, { ok: true });
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: r + lembreteDeParalelo(todosDaTarefa, spawns.length) });
                 continue;
@@ -1326,10 +1415,12 @@ async function runAct(userPrompt, opts) {
             if (tc.name === 'planejar_producao') {
                 algoRodou = true;
                 fala.acao(tc.name, tc.arguments, profundidade);
+                const idA = anotar(tc, 'permitida');
                 const r = await rodarDiretor(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                 });
                 logResult(tc.name, r, profundidade);
+                auditoria.depois(idA, r);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
                 continue;
             }
@@ -1344,10 +1435,12 @@ async function runAct(userPrompt, opts) {
                 algoRodou = true;
                 garantirPasta();
                 fala.acao(tc.name, tc.arguments, profundidade);
+                const idA = anotar(tc, 'permitida');
                 const r = await rodarPipeline(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, livro, autorizar, controle: portaoControle,
                 });
                 logResult(tc.name, r, profundidade);
+                auditoria.depois(idA, r);
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
                 if (r && r.ok && catalogo.escreveArquivo(tc.name)) temPasta = true;
@@ -1362,6 +1455,7 @@ async function runAct(userPrompt, opts) {
             const eco = repeticao.ver(jaChamado, tc.name, tc.arguments);
             if (eco.repetida) {
                 voltasEmFalso++;
+                anotar(tc, 'recusada', `repetida (${eco.vezes}ª vez) — não executou de novo`);
                 /* RELER SEM MUDANÇA devolve o que já foi lido, uma vez.
                    O aviso seco ("o resultado está na conversa acima") mentia
                    depois do `compactar`: a leitura velha já tinha virado 300
@@ -1377,6 +1471,11 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
+            /* Só conta o que passou do freio de repetição: a chamada idêntica
+               já é barrada lá (e a rodada parada desiste sozinha). Aqui entra
+               o que escapa dele — a fatia sobreposta, a volta sem nada novo. */
+            motivoTravou = motivoTravou || travado.observar(circulo, tc.name, tc.arguments, pastaAtual);
+
             if (criarPasta && catalogo.criaProjeto(tc.name, tc.arguments)) garantirPasta();
 
             /* RELER O QUE ACABOU DE ESCREVER. O modelo grátis escreve o
@@ -1413,6 +1512,7 @@ async function runAct(userPrompt, opts) {
 
             if (tc.name === 'pesquisar_referencia' && pesquisasSecas >= 3) {
                 voltasEmFalso++;
+                anotar(tc, 'recusada', 'três pesquisas seguidas sem fonte');
                 messages.push({
                     role: 'tool',
                     tool_call_id: tc.id,
@@ -1431,6 +1531,7 @@ async function runAct(userPrompt, opts) {
             if (permissao.precisa(tc.name)) {
                 const porta = await permissao.pedir(portaoControle, tc.name, tc.arguments, autorizar);
                 if (!porta.ok) {
+                    anotar(tc, 'recusada', porta.error);
                     fala.acao(tc.name, tc.arguments, profundidade);
                     console.log(fala.resultado(profundidade) + c.warn('não autorizado'));
                     registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: porta.error });
@@ -1448,6 +1549,7 @@ async function runAct(userPrompt, opts) {
                 projectDir: pastaAtual, subagent, perguntar: autorizar,
             });
             if (!risco.ok) {
+                anotar(tc, 'recusada', risco.motivo || risco.error);
                 fala.acao(tc.name, tc.arguments, profundidade);
                 console.log(fala.resultado(profundidade) + c.warn(`não autorizado — ${risco.motivo}`));
                 registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: risco.error });
@@ -1467,9 +1569,15 @@ async function runAct(userPrompt, opts) {
                estudio_video transcreve no servidor, e sem eles a ferramenta
                respondia "a transcrição precisa do servidor". */
             traco(`executando ${tc.name}`);
+            const idAcao = idsAdiantados.get(tc.id) || anotar(tc, 'permitida');
             const result = adiantadas.has(tc.id) ? adiantadas.get(tc.id)
                 : await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api });
+            auditoria.depois(idAcao, result);
             traco(`${tc.name} devolveu ok=${result && result.ok}`);
+            if (/^estudio_|^planejar_producao$/.test(tc.name) && result && result.ok !== false) {
+                const id = result.id || (result.projeto && result.projeto.id) || (tc.arguments && tc.arguments.id);
+                if (typeof id === 'string' && id) estudioDaTarefa = id;
+            }
             logResult(tc.name, result, profundidade);
             repeticao.executou(jaChamado, tc.name, tc.arguments);
             if (RELEITURA.has(tc.name) && result && result.ok !== false) {
@@ -1548,6 +1656,18 @@ async function runAct(userPrompt, opts) {
         // A conferência da página tem linha própria: aqui fica só o resto.
         tempos.somar('ferramentas', Date.now() - tTools - (msConferindo - conferindoAntes));
 
+        /* ANDANDO EM CÍRCULO (lib/travado.js): a primeira vez, um empurrão
+           com o que ele está repetindo; a segunda, para — antes da cota. */
+        const giro = travado.fimDaVolta(circulo);
+        const travou = finished ? null : travado.decidir(circulo, motivoTravou || giro);
+        if (travou && travou.acao === 'empurrar') {
+            traco(`travado: ${motivoTravou || giro}`);
+            messages.push({ role: 'user', content: travou.texto });
+        } else if (travou) {
+            paradoPorTravar = travou.texto;
+            break;
+        }
+
         // Uma volta inteira sem executar nada é o modelo preso. Insistir custa
         // um pedido ao servidor por volta, e as 15 voltas saíam caras para
         // terminar no mesmo lugar — melhor parar e devolver a vez ao usuário.
@@ -1587,6 +1707,11 @@ async function runAct(userPrompt, opts) {
     // que "parou sem concluir" não pode virar fato para o passo seguinte.
     const concluiu = Boolean(finalText) && !PARAR;
 
+    if (paradoPorTravar && !finalText) {
+        finalText = paradoPorTravar;
+        if (!subagent) fala.aviso(finalText);
+    }
+
     if (PARAR && !finalText) {
         finalText = 'Parado por você (Esc Esc). O que já foi feito, ficou feito.';
         if (!subagent) fala.aviso(finalText);
@@ -1609,7 +1734,9 @@ async function runAct(userPrompt, opts) {
     // (buildMemoryContext), e sessão sem projeto nomeado (ex.: primeiro pedido
     // antes de /project) tem `projectName` undefined mesmo já tendo mexido em
     // arquivo de verdade — a memória era descartada nesse caso, sempre.
-    if (!subagent && temPasta) {
+    // A raiz de trabalho não é projeto: um memory.md solto em ~/primocode
+    // era o que um pedido de vídeo (que trabalha na raiz) deixava para trás.
+    if (!subagent && temPasta && require('path').resolve(pastaAtual) !== require('path').resolve(cfg.ROOT_DIR)) {
         cfg.appendProjectMemory(pastaAtual, `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
     }
 
@@ -1639,6 +1766,10 @@ async function runAct(userPrompt, opts) {
         // de o usuário ter mandado parar.
         parado: PARAR,
         concluiu,
+        // Onde terminou: o mudar_pasta pode ter trocado no meio.
+        pasta: pastaAtual,
+        // O projeto do Estúdio em que se mexeu, para a memória ir para a pasta dele.
+        estudio: estudioDaTarefa,
     };
 }
 
@@ -1665,6 +1796,7 @@ async function runSubagent(args, ctx) {
         permissoes,
         autorizar: ctx.autorizar,
         controle: ctx.controle,   // o mesmo objeto: a resposta vale para todos
+        rotulo: `subagente: ${String(descricao).slice(0, 60)}`,
     });
 
     /* O que o subagente fez entra no livro de quem o chamou. Sem isto, o