primocode 9.10.0 → 10.0.9

package/lib/browser.js

@@ -14,6 +14,7 @@
 
 'use strict';
 
+const snapshot = require('./snapshot.js');
 const fs = require('fs');
 const os = require('os');
 const net = require('net');
@@ -22,9 +23,36 @@ const http = require('http');
 const crypto = require('crypto');
 const { spawn, execSync } = require('child_process');
 
-const PROFILE_DIR = path.join(os.homedir(), '.primocode', 'chrome-profile');
+const PERFIL_VISIVEL = path.join(os.homedir(), '.primocode', 'chrome-profile');
 // Dentro da faixa 3100-3199 do ambiente local, para o start.sh cuidar dela.
-const DEBUG_PORT = Number(process.env.PRIMOCODE_CDP_PORT || 3199);
+const PORTA_VISIVEL = Number(process.env.PRIMOCODE_CDP_PORT || 3199);
+
+/* ── VISÍVEL SÓ QUANDO A PESSOA PEDIU ────────────────────────────────────
+ *   "toda vez que eu mando alguma coisa pra ele ele abre umas 10.000 abas
+ *    do Chrome — ele nem usa — e eu fecho e ele abre de novo" (Joel, 02/10)
+ * As ferramentas browser_* vão para o modelo em todo pedido, e ele as usa
+ * para PESQUISAR (o motion da Paris Group subiu o Chrome às 09:41 sem
+ * ninguém pedir navegador). Agora o terminal diz, por pedido, se a pessoa
+ * quer ver (definirVisivel): sem pedido de navegador, as mesmas ferramentas
+ * rodam num Chrome --headless de perfil e porta próprios, que nunca abre
+ * janela nem aba na tela — e morre com o processo. */
+const PERFIL_ESCONDIDO = path.join(os.homedir(), '.primocode', 'chrome-escondido');
+const PORTA_ESCONDIDA = Number(process.env.PRIMOCODE_CDP_PORT_ESCONDIDO || 3197);
+let visivel = true;
+let DEBUG_PORT = PORTA_VISIVEL;
+let PROFILE_DIR = PERFIL_VISIVEL;
+
+function definirVisivel(sim) {
+    const quer = sim !== false;
+    if (quer === visivel) return visivel;
+    visivel = quer;
+    DEBUG_PORT = quer ? PORTA_VISIVEL : PORTA_ESCONDIDA;
+    PROFILE_DIR = quer ? PERFIL_VISIVEL : PERFIL_ESCONDIDO;
+    // A sessão aberta é do outro navegador: a próxima ação conecta no certo.
+    if (currentSession) { try { currentSession.close(); } catch { /* já fechou */ } currentSession = null; }
+    return visivel;
+}
+function estaVisivel() { return visivel; }
 
 // ---- Helpers ---------------------------------------------------
 /* O Chromium que o Playwright baixa. Ele não fica no PATH nem em /Applications
@@ -413,12 +441,20 @@ async function ensureChromeRunning() {
         args.push('--no-sandbox');
     }
     // Sem interface gráfica (CI, servidor): PRIMOCODE_BROWSER_HEADLESS=1.
-    if (process.env.PRIMOCODE_BROWSER_HEADLESS === '1' || process.env.PRIMOCODE_BROWSER_HEADLESS === 'true') {
-        args.push('--headless=new', '--disable-gpu', '--disable-dev-shm-usage');
+    // E sempre que a pessoa não pediu para ver (definirVisivel).
+    const escondido = !visivel;
+    if (escondido || process.env.PRIMOCODE_BROWSER_HEADLESS === '1' || process.env.PRIMOCODE_BROWSER_HEADLESS === 'true') {
+        args.push('--headless=new', '--disable-gpu', '--disable-dev-shm-usage', '--mute-audio');
     }
     args.push('about:blank');
     chromeChild = spawn(chrome, args, { detached: true, stdio: 'ignore' });
     chromeChild.on('error', () => {});
+    /* O escondido morre com o processo: ninguém o vê para fechar, e um
+       headless órfão por sessão era o que o revisor deixava em 24/09. */
+    if (escondido) {
+        const filho = chromeChild;
+        process.once('exit', () => { try { process.kill(-filho.pid); } catch { try { filho.kill(); } catch { /* já morreu */ } } });
+    }
     chromeChild.unref();
 
     // Espera a porta responder
@@ -491,6 +527,55 @@ async function open(url) {
     return { ok: true, url };
 }
 
+/* ── ABRIR À VISTA ────────────────────────────────────────────────────────
+ *   "Peço pra ele abrir o Chrome e o YouTube: em vez de só abrir, ele mostra
+ *    o mouse dele abrindo o Chrome, pesquisando…" (30/09)
+ * O cursor do PrimoCode (voz/primo_voz/cursor.py, macOS) vai até a barra de
+ * endereço da janela de verdade, clica, digita o endereço letra por letra e
+ * aperta Enter — quem olha vê o computador sendo usado. A janela vem do CDP
+ * (Browser.getWindowForTarget), então o clique cai na barra mesmo com a
+ * janela em qualquer lugar da tela. Sem cursor (outro SO, sem permissão),
+ * navega direto, como antes. */
+async function abrirVisivel(url) {
+    // Escondido não tem janela para o cursor ir: navega direto.
+    if (!visivel) return open(url);
+    await ensure();
+    const cursor = require('./cursor.js');
+    if (!verSeta() || !cursor.disponivel()) return open(url);
+    try { await currentSession.send('Page.bringToFront'); } catch { /* segue */ }
+    let janela = null;
+    try {
+        const alvo = await currentSession.send('Target.getTargetInfo');
+        const w = await currentSession.send('Browser.getWindowForTarget', alvo && alvo.targetInfo ? { targetId: alvo.targetInfo.targetId } : {});
+        janela = w && w.bounds;
+    } catch { janela = null; }
+    if (!janela || janela.left == null) return open(url);
+    // A barra fica uns 58 pt abaixo do topo da janela (abas + barra), a ~30% da largura.
+    const x = Math.round(janela.left + Math.min(420, janela.width * 0.3));
+    const y = Math.round(janela.top + 58);
+    const passos = [
+        ['clicar', { x, y, botao: 'esquerdo', rotulo: 'barra de endereço' }],
+        ['tecla', { combo: 'cmd+a' }],
+        ['digitar', { texto: url.replace(/^https?:\/\//, ''), rotulo: 'digitando o endereço' }],
+        ['tecla', { combo: 'enter' }],
+    ];
+    for (const [cmd, args] of passos) {
+        const r = await cursor.mandar(cmd, args);
+        if (!r || r.ok === false) return open(url);      // sem permissão de Acessibilidade: navega direto
+    }
+    const deadline = Date.now() + 20000;
+    await sleep(600);
+    while (Date.now() < deadline) {
+        try {
+            const r = await currentSession.send('Runtime.evaluate', { expression: 'document.readyState + "|" + location.href', returnByValue: true });
+            const [estado, href] = String((r.result && r.result.value) || '').split('|');
+            if (estado === 'complete' && href && href !== 'about:blank') return { ok: true, url: href, visivel: true };
+        } catch { /* a página está trocando */ }
+        await sleep(200);
+    }
+    return { ok: true, url, visivel: true };
+}
+
 async function evaluate(js) {
     await ensure();
     const r = await currentSession.send('Runtime.evaluate', {
@@ -658,7 +743,22 @@ async function candidatosNaPagina() {
     try { return JSON.parse(await evaluate(js)) || []; } catch { return []; }
 }
 
+/* O retrato da página com as refs (lib/snapshot.js), já em texto. */
+async function retrato(max = 80) {
+    try {
+        const r = await evaluate(snapshot.scriptDoRetrato(max));
+        return snapshot.formatar(r, max);
+    } catch { return ''; }
+}
+
 async function erroDeSeletor(selector) {
+    // Ref que não existe mais: a página mudou depois da leitura. Listar os
+    // seletores CSS aqui só confundiria — o caminho é ler de novo.
+    if (/data-primo-ref/.test(selector)) {
+        const err = new Error('essa ref não existe mais nesta página — ela mudou depois da leitura. '
+            + 'Estas são as refs de agora:\n' + await retrato(40));
+        return err;
+    }
     const candidatos = await candidatosNaPagina();
     const err = new Error(
         `seletor não encontrado: ${selector}`
@@ -1191,6 +1291,7 @@ function fecharRevisor() {
 }
 
 module.exports = {
+    retrato, abrirVisivel, definirVisivel, estaVisivel,
     SEM_KEYCHAIN,
     scriptDaSeta, verSeta, findChrome,
     open, click, clickText, clickSelector, type, typeInSelector,

package/lib/casar.js

@@ -0,0 +1,108 @@
+/**
+ * casar.js — acha no arquivo o trecho que o modelo MANDOU trocar, mesmo
+ * quando ele não copiou letra por letra.
+ *
+ * O modelo grátis erra o old_string de jeitos previsíveis: um espaço a mais
+ * no fim da linha, a indentação com 2 em vez de 4, o número de linha que o
+ * read_file com offset põe na frente ("12\t…"), um "\n" escapado. Cada erro
+ * desses virava "trecho não encontrado" → read_file de novo → edit de novo:
+ * duas voltas de modelo para um espaço. É o "fica o dia inteiro lendo o que
+ * fez". A ideia vem do opencode (MIT), que encadeia vários "casadores" do
+ * mais estrito ao mais frouxo; o código é nosso.
+ *
+ * A regra de ouro: frouxo, mas NUNCA ambíguo. Cada estratégia só vale se
+ * achar exatamente UM lugar. Dois lugares parecidos é pior que nenhum —
+ * trocar o errado estraga o arquivo calado.
+ *
+ *   achar(conteudo, alvo) → { inicio, fim, como } | { erro: 'nenhum' | 'varios', vezes }
+ */
+
+'use strict';
+
+// Onde está cada linha no texto: [inicio, fim) de cada uma, sem o \n.
+function linhasComPosicao(texto) {
+    const out = [];
+    let i = 0;
+    for (const l of texto.split('\n')) {
+        out.push({ texto: l, inicio: i, fim: i + l.length });
+        i += l.length + 1;
+    }
+    return out;
+}
+
+/* Procura um bloco de linhas do alvo no conteúdo comparando cada linha por
+   `igual`. Devolve todos os lugares (em caracteres do conteúdo original). */
+function porLinhas(conteudo, alvo, normalizar) {
+    const doArquivo = linhasComPosicao(conteudo);
+    let doAlvo = alvo.split('\n');
+    // Linha vazia no começo ou no fim do alvo é quase sempre sobra do modelo.
+    while (doAlvo.length > 1 && !doAlvo[0].trim()) doAlvo = doAlvo.slice(1);
+    while (doAlvo.length > 1 && !doAlvo[doAlvo.length - 1].trim()) doAlvo = doAlvo.slice(0, -1);
+    const alvoN = doAlvo.map(normalizar);
+    if (!alvoN.some(Boolean)) return [];
+    const achados = [];
+    for (let i = 0; i + alvoN.length <= doArquivo.length; i++) {
+        let bate = true;
+        for (let j = 0; j < alvoN.length; j++) {
+            if (normalizar(doArquivo[i + j].texto) !== alvoN[j]) { bate = false; break; }
+        }
+        if (bate) achados.push({ inicio: doArquivo[i].inicio, fim: doArquivo[i + alvoN.length - 1].fim });
+    }
+    return achados;
+}
+
+// Tira a indentação que todas as linhas não vazias têm em comum.
+function semIndentacaoComum(linhas) {
+    const recuos = linhas.filter((l) => l.trim()).map((l) => l.match(/^[ \t]*/)[0].length);
+    const menor = recuos.length ? Math.min(...recuos) : 0;
+    return linhas.map((l) => l.slice(Math.min(menor, l.match(/^[ \t]*/)[0].length)));
+}
+
+function porIndentacao(conteudo, alvo) {
+    const doArquivo = linhasComPosicao(conteudo);
+    const doAlvo = semIndentacaoComum(alvo.replace(/^\n+|\n+$/g, '').split('\n')).map((l) => l.trimEnd());
+    const n = doAlvo.length;
+    if (!doAlvo.some((l) => l.trim())) return [];
+    const achados = [];
+    for (let i = 0; i + n <= doArquivo.length; i++) {
+        const janela = semIndentacaoComum(doArquivo.slice(i, i + n).map((l) => l.texto)).map((l) => l.trimEnd());
+        if (janela.every((l, j) => l === doAlvo[j])) {
+            achados.push({ inicio: doArquivo[i].inicio, fim: doArquivo[i + n - 1].fim });
+        }
+    }
+    return achados;
+}
+
+function ocorrencias(conteudo, alvo) {
+    const out = [];
+    if (!alvo) return out;
+    let i = conteudo.indexOf(alvo);
+    while (i !== -1) { out.push({ inicio: i, fim: i + alvo.length }); i = conteudo.indexOf(alvo, i + alvo.length); }
+    return out;
+}
+
+/* Do mais estrito ao mais frouxo. O primeiro que achar UM lugar vence; o que
+   achar vários para a busca ali mesmo (ficar mais frouxo só pioraria). */
+const ESTRATEGIAS = [
+    ['exato', (c, a) => ocorrencias(c, a)],
+    // "12\t  <div>" — o prefixo que o read_file com offset põe em cada linha.
+    ['sem número de linha', (c, a) => (/^\s*\d+\t/m.test(a) ? ocorrencias(c, a.replace(/^\s*\d+\t/gm, '')) : [])],
+    // "\\n" e "\\t" que vieram escapados de um JSON mal montado.
+    ['sem escape', (c, a) => (/\\[nt"]/.test(a) && !/\\[nt"]/.test(c)
+        ? ocorrencias(c, a.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"')) : [])],
+    ['espaço no fim da linha', (c, a) => porLinhas(c, a, (l) => l.trimEnd())],
+    ['linha aparada', (c, a) => porLinhas(c, a, (l) => l.trim())],
+    ['indentação', (c, a) => porIndentacao(c, a)],
+    ['espaço normalizado', (c, a) => porLinhas(c, a, (l) => l.replace(/\s+/g, ' ').trim())],
+];
+
+function achar(conteudo, alvo) {
+    for (const [como, f] of ESTRATEGIAS) {
+        const achados = f(conteudo, alvo);
+        if (achados.length === 1) return { ...achados[0], como };
+        if (achados.length > 1) return { erro: 'varios', vezes: achados.length, como };
+    }
+    return { erro: 'nenhum' };
+}
+
+module.exports = { achar, ocorrencias };

package/lib/catalogo.js

@@ -87,12 +87,16 @@ const GRUPOS = [
               args: 'id. PREFIRA roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, '
                 + 'partes:[{tipo, fala, …}]} — o PrimoCode faz o layout, a voz com entonação, os ícones, a música e os sons. '
                 + 'Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens} passos{titulo,itens} '
-                + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link}. '
+                + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
+                + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). '
+                + 'estilo: hibrido (PADRÃO: foto e vídeo reais que não param + o motion por cima; dê busca:"termo em inglês" por parte para o b-roll) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; é o do modo sem referências e o de quem pede motion/animação; com modelo3d o produto 3D entra numa batida) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | impacto | cinema. '
+                + 'marca e lancamento aceitam visual:orbe|vetor|estrela|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
                 + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '
                 + 'motivo (opcional): fica no caderno. voltarPara (opcional): nome de uma versão. '
                 + 'Sem plano nem cenas, LÊ o plano atual. '
-                + 'Cada elemento é {tipo: texto|forma|imagem|video|icone|legenda|componente} com x, y, cor, tamanho e '
+                + 'Cada elemento é {tipo: texto|forma|imagem|video|icone|legenda|componente|kit} com x, y, cor, tamanho e '
                 + '"anima": {propriedade: [{t,v,e}]} — quadros-chave em segundos. A cena tem "camera": {zoom,x,y,rotacao} e '
                 + '"perspectiva" para 3D. NÃO existe layout pronto nem tema — cada propriedade do vídeo é escolha sua, a cada vídeo.' },
 

package/lib/claude-engine.js

@@ -575,6 +575,40 @@ function promptDoProtocolo(payload) {
         + '\n\nResponda com exatamente UM bloco marcado.';
 }
 
+/* O `claude -p` ASSÍNCRONO. Era execFileSync: enquanto o Claude pensava (um
+   minuto, dois), o PrimoCode inteiro parava — sem spinner, sem recado, sem
+   Esc Esc. E o teto de 180 s estourava justo quando ele escrevia um arquivo
+   grande, e o erro saía cru na tela ("Command failed: claude -p …"). Agora
+   roda em paralelo, com 10 min de teto, uma segunda tentativa, e o erro
+   diz o que o Claude disse. */
+function rodarClaude(args, input, { timeout = 600000, tentativas = 2 } = {}) {
+    const { spawn } = require('child_process');
+    const umaVez = () => new Promise((resolve, reject) => {
+        const p = spawn('claude', args, { env: process.env, stdio: ['pipe', 'pipe', 'pipe'], ...(SEM_APARECER.windowsHide ? { windowsHide: true } : {}) });
+        let out = '', err = '';
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} reject(new Error(`o Claude Code não respondeu em ${Math.round(timeout / 60000)} min`)); }, timeout);
+        p.stdout.on('data', (d) => { out += d; });
+        p.stderr.on('data', (d) => { err += d; });
+        p.on('error', (e) => { clearTimeout(relogio); reject(e); });
+        p.on('close', (code) => {
+            clearTimeout(relogio);
+            if (code === 0) return resolve(out);
+            // O JSON às vezes vem com is_error e o motivo, mesmo com código != 0.
+            let motivo = '';
+            try { const j = JSON.parse(out); motivo = j.result || j.error || ''; } catch { /* sem json */ }
+            reject(new Error(`o Claude Code saiu com ${code}: ${String(motivo || err || out).replace(/\s+/g, ' ').trim().slice(0, 300)}`));
+        });
+        p.stdin.end(input);
+    });
+    return (async () => {
+        let ultimo;
+        for (let i = 0; i < tentativas; i++) {
+            try { return await umaVez(); } catch (e) { ultimo = e; }
+        }
+        throw ultimo;
+    })();
+}
+
 async function requestActViaHeadless(payload, onEvent) {
     const corpoBootstrap = corpoDoProtocolo();
     const prompt = promptDoProtocolo(payload);
@@ -585,27 +619,14 @@ async function requestActViaHeadless(payload, onEvent) {
     // O prompt vai por STDIN, nunca por argumento: argumento tem limite de
     // tamanho (a conversa cresce) e qualquer conteúdo começando com traço
     // seria lido como opção. stdin não tem nenhum dos dois problemas.
-    const saida = execFileSync('claude', [
-        '-p',
-        '--output-format', 'json',
-        '--dangerously-skip-permissions',
-        ...argsDoMotor(),
-    ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
-        env: process.env, ...SEM_APARECER });
+    const saida = await rodarClaude(['-p', '--output-format', 'json', '--dangerously-skip-permissions', ...argsDoMotor()], prompt);
     const r = JSON.parse(saida);
     // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
     // diagnóstico do que saiu errado. Barata: o prompt é curto, e evita que
     // um erro de sintaxe do motor vire erro na cara do usuário.
-    const pedirCorrecao = (aviso) => {
-        const s = execFileSync('claude', [
-            '-p', '--output-format', 'json', '--dangerously-skip-permissions',
-            ...argsDoMotor(),
-        ], {
-            encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
-            env: process.env,
-            input: promptDeCorrecao(aviso),
-            ...SEM_APARECER,
-        });
+    const pedirCorrecao = async (aviso) => {
+        const s = await rodarClaude(['-p', '--output-format', 'json', '--dangerously-skip-permissions', ...argsDoMotor()],
+            promptDeCorrecao(aviso), { timeout: 300000, tentativas: 1 });
         return JSON.parse(s).result || '';
     };
     await emitirDecisao(r.result || '', onEvent, pedirCorrecao, 0, nomesDasTools(payload));

package/lib/codex-engine.js

@@ -131,22 +131,40 @@ function recusouOModelo(texto) {
  * `--model` e avisa — cair para o padrão da conta é melhor que a tarefa
  * morrer por causa de um nome que mudou de catálogo.
  */
-function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
+/* O Codex ASSÍNCRONO, pelo mesmo motivo do claude -p (lib/claude-engine.js):
+   o execFileSync congelava o PrimoCode inteiro — spinner, recado, Esc Esc —
+   enquanto o Codex pensava. O erro mantém stdout/stderr para o diagnóstico. */
+function rodarAssincrono(args, entrada) {
+    const { spawn } = require('child_process');
+    return new Promise((resolve, reject) => {
+        const p = spawn(CODEX, args, { env: process.env, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+        let out = '', err = '';
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} const e = new Error(`o Codex não respondeu em ${Math.round(TEMPO / 60000)} min`); e.stderr = err; e.stdout = out; reject(e); }, TEMPO);
+        p.stdout.on('data', (d) => { out += d; if (out.length > BUFFER) { try { p.kill(); } catch {} } });
+        p.stderr.on('data', (d) => { err += d; });
+        p.on('error', (e) => { clearTimeout(relogio); reject(e); });
+        p.on('close', (code) => {
+            clearTimeout(relogio);
+            if (code === 0) return resolve(out);
+            const e = new Error(`Command failed: codex (saiu com ${code})`); e.stderr = err; e.stdout = out; reject(e);
+        });
+        p.stdin.end(entrada);
+    });
+}
+
+async function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
     // A chave própria da pessoa, quando ela configurou uma. Sem configuração
     // o ambiente vai INTACTO — passar a variável vazia apagaria a chave que
     // ela já tem exportada no shell, e o Codex pararia de funcionar por ter
     // sido "configurado".
-    const rodar = executor || ((args, entrada) => execFileSync(CODEX, args, {
-        encoding: 'utf-8', timeout: TEMPO, input: entrada, maxBuffer: BUFFER,
-        env: process.env, ...SEM_APARECER,
-    }));
+    const rodar = executor || rodarAssincrono;
     try {
-        return rodar(argsDoExec(), prompt);
+        return await rodar(argsDoExec(), prompt);
     } catch (e) {
         const detalhe = `${e.message || ''}\n${(e.stderr || '')}\n${(e.stdout || '')}`;
         if (MODELO_CODEX && recusouOModelo(detalhe)) {
             avisar(`o Codex não aceitou o modelo ${MODELO_CODEX} — indo com o padrão da sua conta`);
-            return rodar(argsDoExec({ comModelo: false }), prompt);
+            return await rodar(argsDoExec({ comModelo: false }), prompt);
         }
         throw new Error(primeiraLinhaUtil(detalhe) || e.message);
     }
@@ -185,12 +203,12 @@ async function requestAct(server, payload, onEvent) {
             return;
         }
         const prompt = claude.promptDoProtocolo(payload);
-        const saida = chamarCodex(prompt, { avisar: (m) => onEvent({ aviso: m }) });
+        const saida = await chamarCodex(prompt, { avisar: (m) => onEvent({ aviso: m }) });
 
         // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
         // diagnóstico do que saiu errado. Barata, e evita que um erro de forma
         // do motor vire erro na cara de quem pediu a tarefa.
-        const pedirCorrecao = (aviso) => chamarCodex(claude.promptDeCorrecao(aviso));
+        const pedirCorrecao = (aviso) => chamarCodex(claude.promptDeCorrecao(aviso));   // devolve promessa: quem chama dá await
 
         await claude.emitirDecisao(saida, onEvent, pedirCorrecao, 0,
             claude.nomesDasTools(payload));

package/lib/config.js

@@ -74,8 +74,11 @@ function ensureDir(dir) {
     try { fs.mkdirSync(dir, { recursive: true }); } catch {}
 }
 
+// O dia LOCAL: toISOString é UTC, e no Brasil depois das 21h a memória saía
+// datada no dia seguinte.
 function today() {
-    return new Date().toISOString().split('T')[0];
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
 }
 
 function ensureStructure() {
@@ -99,12 +102,16 @@ function slugify(name) {
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '')
-        .slice(0, 60);
+        .slice(0, 60)
+        .replace(/-+$/, '');   // o corte pode deixar hífen no fim
 }
 
 function createProjectDir(projectName) {
     ensureStructure();
-    const slug = slugify(projectName);
+    /* Nome sem letra nem número ("!!!", só emoji, só japonês) dava slug
+       VAZIO — e path.join(ROOT_DIR, '') é a própria raiz: o "projeto" virava
+       ~/primocode, com memory.md gravado nela. */
+    const slug = slugify(projectName) || `projeto-${today()}`;
     const projectDir = path.join(ROOT_DIR, slug);
     ensureDir(projectDir);
     const memoryPath = path.join(projectDir, 'memory.md');

package/lib/cursor.js

@@ -95,7 +95,16 @@ function subir() {
             };
             proc.on('exit', morreu);
             proc.on('error', morreu);
-            setTimeout(() => { if (!subiu) { semCursor = 'o cursor demorou demais para abrir'; resolve(false); } }, 20000);
+            // Demorou demais: desiste E mata — senão o Python ficava órfão, e o
+            // `pronto` guardado como false deixava o cursor fora a sessão toda.
+            const teto = setTimeout(() => {
+                if (subiu) return;
+                semCursor = 'o cursor demorou demais para abrir';
+                try { proc && proc.kill(); } catch { /* já morreu */ }
+                pronto = null;
+                resolve(false);
+            }, 20000);
+            if (teto.unref) teto.unref();
             // O cursor não pode segurar o PrimoCode aberto na saída.
             proc.unref();
             proc.stdout.unref && proc.stdout.unref();

package/lib/entrada.js

@@ -43,6 +43,10 @@ const { c, visibleWidth, truncate } = require('./ui.js');
 
 // ── O desenho ────────────────────────────────────────────────────────────
 
+/** A etiqueta de colagem em destaque (fininha, na cor da marca), sem mudar a largura. */
+const RE_ETIQUETA = /\[Colado #\d+ · [^\]]+\]/g;
+function pintarEtiquetas(s) { return String(s).replace(RE_ETIQUETA, (m) => c.brand(m) + '\x1b[38;5;254m'); }
+
 const BORDA = { ne: '╭', no: '╮', se: '╰', so: '╯', h: '─', v: '│' };
 
 /** Preenche até `w` colunas VISÍVEIS (códigos de cor não ocupam coluna). */
@@ -128,6 +132,12 @@ function montar(e) {
 
     const out = [];
     const regua = (bash ? c.warn : c.dim)(BORDA.h.repeat(largura));
+    /* O SPINNER MORA AQUI, na linha logo acima da caixa. Ele escrevia direto
+       no terminal com "\r" a cada 80 ms, sem quebra de linha — e a caixa,
+       que espera a linha fechar para se redesenhar, ficava apagada enquanto
+       ele girasse: o que se digitava não aparecia, e a barra de status
+       sumia ("não consigo digitar enquanto ele trabalha"). */
+    if (e.spinner) out.push(' ' + truncate(e.spinner, largura - 2));
     out.push(regua);
 
     const vazio = !String(e.texto).length;
@@ -137,13 +147,14 @@ function montar(e) {
             : c.dim('┆ ');
         // O "!" some do texto desenhado: quem vê "$ " já sabe que é shell, e
         // mostrar os dois é mostrar a mesma informação duas vezes.
-        let conteudo = c.white(i === 0 && bash ? l.texto.replace(/^\s*!/, '') : l.texto);
+        let conteudo = pintarEtiquetas(c.white(i === 0 && bash ? l.texto.replace(/^\s*!/, '') : l.texto));
         // O fantasma só existe na última linha e só com o cursor no fim dela:
         // desenhado no meio do texto, ele empurraria o que vem depois.
         if (i === linhas.length - 1 && e.fantasma && cursor === String(e.texto).length) {
             conteudo += c.dim(e.fantasma);
         }
-        if (i === 0 && vazio && e.vazio) conteudo = c.dim(e.vazio);
+        if (i === 0 && vazio && e.ocupado) conteudo = c.dim('mande um recado — ele entra na tarefa depois do passo atual');
+        else if (i === 0 && vazio && e.vazio) conteudo = c.dim(e.vazio);
         // Sem `encher`: sem barra à direita não há nada para alinhar, e o
         // espaço sobrando só apagaria o que estivesse embaixo.
         out.push(' ' + marca + conteudo);
@@ -315,7 +326,8 @@ class Entrada extends EventEmitter {
     suspender() { this.suspenso = true; this._apagar(); }
     retomar() { this.suspenso = false; if (this.ativo && !this.fechado) this._desenhar(); }
 
-    /** O agente está trabalhando: a caixa esmaece e o Enter não manda nada. */
+    /** O agente está trabalhando: a caixa esmaece, e o Enter manda um RECADO
+     *  que entra na tarefa em curso (a caixa de entrada de lib/act.js). */
     trabalhando(sim) {
         if (this.ocupado === !!sim) return;
         this.ocupado = !!sim;
@@ -324,6 +336,15 @@ class Entrada extends EventEmitter {
 
     prompt() { if (!this.suspenso && this.tty && !this.fechado) this._desenhar(); }
 
+    /** O spinner (lib/ui.js) desenha por aqui quando há caixa: uma linha
+     *  acima dela, redesenhada junto — nunca um "\r" solto por cima. */
+    mostrarSpinner(texto) {
+        const novo = texto || '';
+        if (novo === (this.spinnerTexto || '')) return;
+        this.spinnerTexto = novo;
+        if (this.desenhado && !this._meiaLinha) this._redesenhar();
+    }
+
     /** Escreve texto ACIMA da caixa — é por onde todo o resto do programa fala. */
     escreverAcima(texto) {
         if (!this.desenhado) { this.escreverCru(texto); return; }
@@ -340,7 +361,40 @@ class Entrada extends EventEmitter {
         this._mudou();
     }
 
-    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this._mudou(); }
+    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this.colados = new Map(); this._mudou(); }
+
+    /* COLAR VIRA ETIQUETA, como no Claude Code: texto grande colado (várias
+       linhas, ou mais de 300 caracteres) entra na caixa como
+       "[Colado #1 · 42 linhas]" — a caixa não vira um paredão, dá para
+       escrever o pedido em volta, e no Enter a etiqueta volta a ser o texto
+       inteiro. O que é curto entra como texto mesmo. */
+    colar(texto) {
+        const t = String(texto || '');
+        if (!t) return;
+        const linhas = t.split('\n').length;
+        if (linhas < 3 && t.length <= 300) return this.write(t);
+        if (!this.colados) this.colados = new Map();
+        const n = this.colados.size + 1;
+        const etiqueta = `[Colado #${n} · ${linhas > 1 ? `${linhas} linhas` : `${t.length} caracteres`}]`;
+        this.colados.set(etiqueta, t);
+        this.write(etiqueta);
+    }
+
+    /** A linha com cada etiqueta trocada pelo texto que ela guarda. */
+    expandir(linha) {
+        if (!this.colados || !this.colados.size) return linha;
+        let out = linha;
+        for (const [et, t] of this.colados) out = out.split(et).join(t);
+        return out;
+    }
+
+    /** A etiqueta que termina exatamente no cursor (o backspace apaga ela inteira). */
+    _etiquetaAntes() {
+        if (!this.colados) return null;
+        const antes = this.line.slice(0, this.cursor);
+        for (const et of this.colados.keys()) if (antes.endsWith(et)) return et;
+        return null;
+    }
 
     /**
      * A PRÓXIMA linha é senha: a caixa desenha `•` no lugar das letras, não
@@ -361,6 +415,7 @@ class Entrada extends EventEmitter {
             status: this.op.status ? this.op.status() : [],
             menu: this.menu,
             ocupado: this.ocupado,
+            spinner: this.spinnerTexto || '',
         });
     }
 
@@ -434,11 +489,11 @@ class Entrada extends EventEmitter {
         const seq = (key && key.sequence) || ch || '';
 
         // Colagem entre marcas: tudo que vier até a marca de fim é texto.
-        if (seq.includes('\x1b[200~')) { this.colando = true; }
+        if (seq.includes('\x1b[200~')) { this.colando = true; this.bufColagem = ''; }
         if (this.colando) {
             const limpo = seq.replace('\x1b[200~', '').replace('\x1b[201~', '');
-            if (limpo) this.write(limpo.replace(/\r/g, '\n'));
-            if (seq.includes('\x1b[201~')) this.colando = false;
+            if (limpo) this.bufColagem += limpo.replace(/\r\n?/g, '\n');
+            if (seq.includes('\x1b[201~')) { this.colando = false; this.colar(this.bufColagem); this.bufColagem = ''; }
             return;
         }
 
@@ -476,7 +531,15 @@ class Entrada extends EventEmitter {
                 return;
             }
 
-            case 'backspace':
+            case 'backspace': {
+                const et = this._etiquetaAntes();
+                if (et) {
+                    this.line = this.line.slice(0, this.cursor - et.length) + this.line.slice(this.cursor);
+                    this.cursor -= et.length;
+                    this.colados.delete(et);
+                    return this._mudou();
+                }
+            }
                 if (this.cursor > 0) {
                     this.line = this.line.slice(0, this.cursor - 1) + this.line.slice(this.cursor);
                     this.cursor--;
@@ -583,7 +646,9 @@ class Entrada extends EventEmitter {
 
     _enviar() {
         if (this.menu) return this._escolherDoMenu();
-        const texto = this.line;
+        const visto = this.line;
+        const texto = this.expandir(visto);
+        this.colados = new Map();
         const oculto = this.oculto;
         this.oculto = false;
         this.line = '';
@@ -597,7 +662,8 @@ class Entrada extends EventEmitter {
         this._apagar();
         if (texto.trim() && !oculto) {
             const marca = c.brand('❯ ');
-            this.escreverCru(texto.split('\n').map((l, i) => (i ? '  ' : marca) + c.white(l)).join('\n') + '\n');
+            // Na tela fica a etiqueta (o que se viu ao mandar); quem vai ao agente é o texto inteiro.
+            this.escreverCru(visto.split('\n').map((l, i) => (i ? '  ' : marca) + pintarEtiquetas(c.white(l))).join('\n') + '\n');
             if (this.historico[this.historico.length - 1] !== texto) this.historico.push(texto);
         }
         this._desenhar();
@@ -607,4 +673,4 @@ class Entrada extends EventEmitter {
 
 function criar(op) { return new Entrada(op).iniciar(); }
 
-module.exports = { criar, Entrada, montar, quebrar, encher };
+module.exports = { criar, Entrada, montar, quebrar, encher, pintarEtiquetas };