primocode 11.2.0 → 11.3.0

package/lib/cli/sessao.js

@@ -13,6 +13,7 @@ const os = require('os');
 
 const pkg = require('../../package.json');
 const ui = require('../tui/ui');
+const tela = require('../tui/tela.js');
 const entrada = require('../tui/entrada');
 const { c, welcomeBox, Spinner } = ui;
 const { escolherModo } = require('../modo.js');
@@ -444,9 +445,10 @@ function barraDeStatus() {
     direita.push(...SL.partes({ modelo: SL.modelo(), ctxPct: uso.pct, tokensHoje: SL.tokensDeHoje(), c }));
     const aprovar = require('../cli-nova.js').praAprovar();
     if (aprovar) direita.push(c.warn(`${aprovar} pra aprovar`));
-    direita.push(state.trabalhando && rl && rl.ocupado
+    const atalhos = state.trabalhando && rl && rl.ocupado
         ? c.warn('trabalhando') + c.dim(' · ') + c.white('esc esc') + c.dim(' para')
-        : c.white('tab') + c.dim(' modos  ') + c.white('ctrl+p') + c.dim(' comandos'));
+        : c.white('tab') + c.dim(' modos  ') + c.white('ctrl+p') + c.dim(' comandos');
+    direita.push(atalhos);
 
     /* O modo DENTRO do painel. No auto, depois do primeiro pedido, ele diz
        qual modo acabou respondendo — senão você nunca sabe quem respondeu. */
@@ -455,9 +457,12 @@ function barraDeStatus() {
     if (state.mode === 'auto' && state.modoEfetivo) {
         modo += c.dim(' → ') + c.muted(NOME_MODO[state.modoEfetivo] || state.modoEfetivo);
     }
-    modo += c.dim(' · ') + c.white(effort.normalizar(state.config.effort)) + ' ' + c.dim('PrimoCode');
+    /* "Build · Primo Max · esforço alto": o modo, o plano da conta ("Primo Max") e o esforço. */
+    let planoNome = '';
+    try { const eu = conta.atual(); if (eu && eu.plano && eu.plano !== 'free') planoNome = ' ' + String(eu.plano).replace(/^./, (x) => x.toUpperCase()); } catch { /* sem conta */ }
+    modo += c.dim(' · ') + c.white('Primo' + planoNome) + c.dim(' · esforço ') + c.white(effort.normalizar(state.config.effort));
 
-    return { modo, cor, esquerda: partes.join(c.dim(' · ')), direita: direita.join(c.dim('   ')) };
+    return { modo, cor, esquerda: partes.join(c.dim(' · ')), direita: direita.join(c.dim('   ')), atalhos };
 }
 
 /* A barra da direita da tela cheia, como a do OpenCode: o contexto (quantos
@@ -468,20 +473,61 @@ function barraLateral() {
     const dir = state.workDir || process.cwd();
     const ramo = ramoDoGit(dir);
     const m = state.mode === 'auto' && state.modoEfetivo ? state.modoEfetivo : state.mode;
-    const secoes = [
-        { titulo: 'Contexto', linhas: [
-            c.muted(`${uso.tokens.toLocaleString('pt-BR')} tokens`),
-            (uso.pct >= 100 ? c.err : uso.pct >= 70 ? c.warn : c.muted)(`${uso.pct}% usado`),
-        ] },
-        { titulo: 'Modo', linhas: [
-            `${COR_MODO[m] || COR_MODO.auto}${NOME_MODO[m] || m}${c.reset}` + c.muted(` · esforço ${effort.normalizar(state.config.effort)}`),
-        ] },
-    ];
+    const larg = 22;
+    const secoes = [];
+
+    // Contexto: quanto da conversa já foi gasto, com a barra.
+    secoes.push({ titulo: 'Contexto', linhas: [
+        c.muted(`${uso.tokens.toLocaleString('pt-BR')} tokens · ${uso.pct}%`),
+        tela.barraDe(uso.pct, larg, uso.pct >= 100 ? c.err : uso.pct >= 70 ? c.warn : c.brand),
+    ] });
+
+    /* Plano: o plano da CONTA (o que o login confirmou) e o gasto de hoje contra o limite que a
+       pessoa ensinou (/usage limite). O servidor não informa o limite da semana, então ele não é inventado. */
+    try {
+        const eu = conta.atual();
+        const L = require('../config/limite.js');
+        const hoje = L.usoDeHoje().tokens;
+        const lim = L.limiteConhecido();
+        const linhas = [];
+        if (eu && eu.plano) linhas.push(c.muted(`Plano ${String(eu.plano).replace(/^./, (x) => x.toUpperCase())}`));
+        if (lim) {
+            const pct = Math.round((hoje / lim) * 100);
+            linhas.push(c.muted(`${pct}% do limite de hoje`), tela.barraDe(pct, larg, pct >= 100 ? c.err : pct >= 70 ? c.warn : c.brand));
+        } else linhas.push(c.dim(`${hoje.toLocaleString('pt-BR')} tokens hoje`));
+        secoes.push({ titulo: 'Plano', linhas });
+    } catch { /* o plano nunca derruba a tela */ }
+
+    secoes.push({ titulo: 'Modo', linhas: [
+        `${COR_MODO[m] || COR_MODO.auto}${NOME_MODO[m] || m}${c.reset}` + c.muted(` · esforço ${effort.normalizar(state.config.effort)}`),
+    ] });
+
+    // Tarefas: o write_todos do agente.
+    const todos = ui.estadoSessao.todos || [];
+    if (todos.length) {
+        const marca = { completed: c.ok('✓'), in_progress: c.brand('●'), pending: c.dim('○') };
+        secoes.push({ titulo: 'Tarefas', linhas: todos.slice(0, 8).map((t) => `${marca[t.status] || c.dim('○')} ` + (t.status === 'completed' ? c.dim(t.content) : t.status === 'in_progress' ? c.white(t.content) : c.muted(t.content))) });
+    }
+
+    // Arquivos alterados, com +N −M.
+    if (ui.estadoSessao.arquivos.size) {
+        const arqs = [...ui.estadoSessao.arquivos.entries()].slice(-8);
+        secoes.push({ titulo: 'Arquivos alterados', linhas: arqs.map(([f, k]) =>
+            c.muted(path.basename(f)) + '  ' + (k.mais ? c.ok('+' + k.mais) : '') + (k.menos ? ' ' + c.err('−' + k.menos) : '')) });
+    }
+
+    // MCP: os servidores configurados (o padrão, o do usuário, o do projeto).
+    try {
+        const nomes = Object.keys(require('../mcp/mcp.js').servidores(dir));
+        if (nomes.length) secoes.push({ titulo: 'MCP', linhas: nomes.slice(0, 5).map((n) => c.ok('●') + ' ' + c.muted(n)) });
+    } catch { /* sem MCP, sem seção */ }
+
     if (state.attachedFiles.length) {
         secoes.push({ titulo: 'Anexos', linhas: state.attachedFiles.map((f) => c.muted(path.basename(f.path))) });
     }
     if (state.controle && state.controle.liberado) secoes.push({ titulo: 'Controle do PC', linhas: [c.warn('liberado até fechar')] });
     return {
+        subtitulo: state.currentProject ? state.currentProject : undefined,
         secoes,
         rodape: [
             c.muted(shortPath(dir)) + (ramo ? c.white(':' + ramo) : ''),
@@ -490,6 +536,83 @@ function barraLateral() {
     };
 }
 
+/* ── A PALETA (ctrl+p) E OS DIÁLOGOS ─────────────────────────────────────
+ * O desenho é do OpenCode: uma lista com busca no meio da tela. O conteúdo é
+ * o que já existe aqui: os comandos de barra, os modos, os agentes da pessoa,
+ * as conversas salvas e os temas. Escolher um item roda o comando de sempre. */
+const ATALHOS_DO_LIDER = { '/clear': 'ctrl+x n', '/projects': 'ctrl+x p', '/estudio': 'ctrl+x s' };
+
+function paletaDeComandos() {
+    const itens = [
+        { secao: 'Sugeridos', nome: 'Nova conversa', cmd: '/clear', tecla: 'ctrl+x n' },
+        { secao: 'Sugeridos', nome: 'Trocar o modo e o esforço', desc: 'auto · primo code · chat', tecla: 'ctrl+x m', acao: (r) => r.abrirDialogo(dialogoModelo()) },
+        { secao: 'Sugeridos', nome: 'Agentes', desc: 'ligar e desligar', tecla: 'ctrl+x a', acao: (r) => r.abrirDialogo(dialogoAgentes()) },
+        { secao: 'Sugeridos', nome: 'Conversas salvas', tecla: 'ctrl+x l', acao: (r) => dialogoSessoes().then((d) => d && r.abrirDialogo(d)) },
+        { secao: 'Sugeridos', nome: 'Tema', desc: 'cor de destaque', tecla: 'ctrl+x t', acao: (r) => r.abrirDialogo(dialogoTema()) },
+        { secao: 'Sugeridos', nome: 'Mostrar ou esconder a barra da direita', tecla: 'ctrl+x b', acao: (r) => { r.lateralOculta = !r.lateralOculta; r._quadroAnterior = null; r._pintar(); } },
+    ];
+    for (const [nome, desc] of comandosDoMenu()) {
+        if (/^(\/uninstall|!comando|\/voice )/.test(nome) || nome.includes(' ') || nome === '/clear') continue;
+        itens.push({ secao: 'Comandos', nome, desc, cmd: nome, tecla: ATALHOS_DO_LIDER[nome] || '', preencher: /\s<|<.*>/.test(desc) && /^\/(dir|worktree|rule|lock|attach|read|run|open|history|howto)$/.test(nome) });
+    }
+    return itens;
+}
+
+function dialogoModelo() {
+    const atual = state.mode;
+    const esforco = effort.normalizar(state.config.effort);
+    const itens = [
+        ['auto', 'Auto', 'o PrimoCode escolhe entre fazer e conversar'],
+        ['primocode', 'Primo Code', 'o agente que cria e edita arquivos'],
+        ['chat', 'Chat', 'só conversa, sem mexer em nada'],
+    ].map(([id, nome, desc]) => ({ secao: 'Modo', nome: (atual === id ? '● ' : '  ') + nome, desc, id }));
+    for (const e of ['low', 'medium', 'high', 'ultracode']) itens.push({ secao: 'Esforço', nome: (esforco === effort.normalizar(e) ? '● ' : '  ') + effort.normalizar(e), desc: e === 'ultracode' ? 'o máximo' : '', esforco: e });
+    return {
+        titulo: 'Modo e esforço', itens,
+        aoEscolher: (it, r) => {
+            if (it.id) { state.mode = it.id; state.modoEfetivo = null; cfg.saveConfig({ mode: it.id }); r.toast(`Modo: ${NOME_MODO[it.id]}`, 'ok'); }
+            else { cfg.saveConfig({ effort: it.esforco }); state.config.effort = it.esforco; r.toast(`Esforço: ${effort.normalizar(it.esforco)}`, 'ok'); }
+            refreshPrompt();
+        },
+    };
+}
+
+function dialogoAgentes() {
+    let lista = [];
+    try { lista = require('../agentes-pessoais').listar({ dir: state.workDir }); } catch { lista = []; }
+    return {
+        titulo: 'Agentes',
+        vazio: 'Nenhum agente. /agentes criar <nome> | <o que faz> | <ofício>',
+        itens: lista.map((a) => ({ nome: (a.ligado ? '● ' : '○ ') + '@' + a.nome, desc: a.descricao || a.oficio || '', agente: a })),
+        aoEscolher: (it, r) => {
+            try {
+                const a = require('../agentes-pessoais').alternar(it.agente.nome, !it.agente.ligado, { dir: state.workDir });
+                r.toast(`@${a.nome} ${a.ligado ? 'ligado' : 'desligado'}`, 'ok');
+            } catch (e) { r.toast(e.message, 'erro'); }
+        },
+    };
+}
+
+async function dialogoSessoes() {
+    if (!conta.atual()) { if (rl) rl.toast('Entre na conta (/login) para ver as conversas salvas', 'aviso'); return null; }
+    const l = await nuvem.listarConversas({ limite: 30 });
+    if (!l.ok || !l.conversas.length) { if (rl) rl.toast(l.ok ? 'Nenhuma conversa salva ainda' : l.error, 'aviso'); return null; }
+    return {
+        titulo: 'Conversas',
+        itens: l.conversas.map((x, i) => ({ nome: x.titulo.slice(0, 44), desc: `${x.mensagens} msg`, tecla: x.atualizada ? new Date(x.atualizada).toLocaleDateString('pt-BR') : '', n: i + 1 })),
+        aoEscolher: (it, r) => { r.line = '/resume ' + it.n; r.cursor = r.line.length; r._enviar(); },
+    };
+}
+
+function dialogoTema() {
+    const atual = ui.temaDoMomento();
+    return {
+        titulo: 'Tema',
+        itens: Object.entries(ui.TEMAS).map(([id, t]) => ({ nome: (atual === id ? '● ' : '  ') + t.nome, id })),
+        aoEscolher: (it, r) => { ui.definirTema(it.id); cfg.saveConfig({ tema: it.id }); r._quadroAnterior = null; r._pintar(); r.toast(`Tema: ${ui.TEMAS[it.id].nome}`, 'ok'); },
+    };
+}
+
 /* O Tab com a caixa vazia gira o modo, como o "tab agents" do OpenCode:
    auto → primo code → chat → auto. A escolha fica salva, como a do /mode. */
 function trocarModo() {
@@ -507,6 +630,7 @@ function refreshPrompt() { if (rl) rl.prompt(); }
 // Enquanto uma pergunta está no ar, a próxima linha digitada é a RESPOSTA dela
 // — não um novo comando. Sem isso o "s" de confirmação virava prompt para a IA.
 let pendingAsk = null;
+let permissaoPendente = null;      // resolve a pergunta de permissão quando a pessoa aperta Esc
 
 /* ── O QUE A PESSOA ADIANTA ──────────────────────────────────────────────
  * Enquanto a abertura corre — e ela demora, porque confere o plano no
@@ -922,6 +1046,30 @@ async function prepararPasta(userText) {
  * entregar o mouse e o teclado.
  */
 async function autorizarControle(oQueVaiFazer, { primeira, tipo } = {}) {
+    /* NA TELA CHEIA a pergunta é um PAINEL AMARELO no meio da conversa (o de permissão do OpenCode):
+       "enter sim · a sempre · esc não". Só o /perms perguntar tem Enter = sim, porque a pessoa pediu para
+       ser perguntada naquele projeto. O primeiro pedido de controle do computador e o que "não tem volta"
+       mantêm o Enter = NÃO (o padrão de quem apertou Enter sem ler não entrega o mouse). */
+    if (rl && rl.cheia) {
+        const enterSim = !!tipo && tipo !== 'perigo';
+        const titulo = tipo === 'perigo' ? 'Isto não tem volta' : primeira ? 'O Primo quer usar o seu computador' : 'Permissão';
+        const w = Math.max(30, (process.stdout.columns || 80) - 2);
+        const teclas = enterSim
+            ? c.white('enter') + c.dim(' sim   ') + c.white('a') + c.dim(' sempre   ') + c.white('esc') + c.dim(' não')
+            : c.white('1') + c.dim(' sim, agora   ') + c.white('a') + c.dim(' sempre   ') + c.white('enter') + c.dim('/') + c.white('esc') + c.dim(' não');
+        console.log('');
+        console.log(tela.painelCor([c.warn(titulo) + '  ' + c.white(oQueVaiFazer), teclas], 'warn', w).join('\n'));
+        const dito = String(await Promise.race([
+            ask(''),
+            new Promise((res) => { permissaoPendente = () => res('esc'); }),
+        ])).trim().toLowerCase().replace(/[.!?,;:…]+/g, ' ').replace(/\s+/g, ' ').trim();
+        permissaoPendente = null;
+        if (dito === 'esc') { pendingAsk = null; console.log('  ' + c.muted('Não autorizado.') + c.dim(' Ele vai resolver por outro caminho.')); return 'nao'; }
+        if (dito === 'a' || /sess|sempre|tudo|todas|^2$/.test(dito)) { console.log('  ' + c.ok('✓ autorizado') + c.dim(' — esta sessão inteira. Fechar o PrimoCode esquece.')); return 'sessao'; }
+        if (dito === '1' || /^(s|sim|ok|pode|agora|y|yes|claro|vai)\b/.test(dito) || (dito === '' && enterSim)) { console.log('  ' + c.ok('✓ autorizado') + c.dim(' — só esta ação')); return 'agora'; }
+        console.log('  ' + c.muted('Não autorizado.') + c.dim(' Ele vai resolver por outro caminho.'));
+        return 'nao';
+    }
     /* O mesmo portão serve ao /permissoes (lib/permission/perigo.js): a pergunta muda de
        cabeçalho, as três respostas são as mesmas. */
     if (tipo) {
@@ -3009,7 +3157,10 @@ async function handleSlash(text) {
         }
 
         case 'clear': state.history = []; state.memoria = memoria.nova();
-            state.gravador.zerar(); console.log(c.ok('Conversa limpa.')); break;
+            state.gravador.zerar();
+            ui.estadoSessao.todos = []; ui.estadoSessao.arquivos.clear();
+            if (rl && rl.cheia) { rl.novaConversa(); rl.toast('Conversa nova', 'ok'); } else console.log(c.ok('Conversa limpa.'));
+            break;
         case 'cls': process.stdout.write('\x1Bc'); break;
 
         /* O /status olha só o servidor. O /doctor olha tudo o que costuma
@@ -3925,6 +4076,7 @@ async function main() {
        contexto, e sem conversa a home põe o logo e a caixa no meio da tela.
        PRIMOCODE_TELA=linha (ou "tela": "linha" no config) volta ao jeito
        antigo, que escreve em linha pelo terminal. */
+    if (state.config.tema) ui.definirTema(state.config.tema);
     const telaCheia = process.stdout.isTTY && process.stdout.rows >= 16
         && (process.env.PRIMOCODE_TELA || state.config.tela || 'cheia') !== 'linha';
     if (!telaCheia) {
@@ -3946,7 +4098,11 @@ async function main() {
         logoAnimado: (quadro, trabalhando) => ui.logoAnimado(state.config.mascot, quadro, trabalhando),
         agora: () => (ui.agora.texto && Date.now() - ui.agora.desde < 10 * 60 * 1000 ? ui.agora.texto : ''),
         versao: VERSION,
-        logo: ui.logoComMascote(state.config.mascot),
+        logo: [...ui.mascot(state.config.mascot), '', ...ui.logoBloco()],
+        logoSimples: ui.logoBloco(),
+        plano: () => { try { const eu = conta.atual(); return eu && eu.plano ? 'Plano ' + String(eu.plano).replace(/^./, (x) => x.toUpperCase()) : ''; } catch { return ''; } },
+        paleta: paletaDeComandos,
+        dialogos: { modelo: dialogoModelo, agente: dialogoAgentes, sessoes: dialogoSessoes, tema: dialogoTema },
         pasta: () => {
             const dir = state.workDir || process.cwd();
             const ramo = ramoDoGit(dir);
@@ -3954,7 +4110,8 @@ async function main() {
         },
     });
     if (telaCheia && state.workDirOrigem === 'padrao') {
-        console.log(c.warn(`  pasta padrão: ${shortPath(state.workDir)}`) + c.dim('  · /dir <pasta> para trabalhar numa sua'));
+        // Um aviso no canto, não uma linha na conversa: a home continua limpa.
+        rl.toast(`pasta padrão: ${shortPath(state.workDir)} · /dir <pasta> para trabalhar numa sua`, 'aviso', 7000);
     }
     /* A última conversa desta pasta, em uma linha (lib/passagem.js). Uma vez por abertura, só aqui (o -p já saiu
        antes) e só se a pessoa não abriu já retomando (-c / --resume). */
@@ -3987,6 +4144,7 @@ async function main() {
      * ela é desenhada pela própria caixa (ver lib/tui/entrada.js). */
     let ultimoEsc = 0;
     rl.on('escape', () => {
+        if (permissaoPendente) { permissaoPendente(); return; }     // Esc na pergunta de permissão = não
         if (!busy) { ultimoEsc = 0; return; }
         const agora = Date.now();
         if (agora - ultimoEsc < 2000) {

package/lib/config/config.js

@@ -343,6 +343,8 @@ function loadConfig() {
         // Piloto automático e agentes em grupo (docs/estrutura.md, seção 9). Desligados por padrão.
         piloto: file.piloto === true,
         grupo: file.grupo === true,
+        // Preferências da tela Configurações (legenda, silêncios, efeitos, voz, formato, idioma, testes).
+        preferencias: preferenciasValidas(file.preferencias),
         // A tela de primeira execução do app (docs/estrutura.md, 16.7): some depois de feita ou pulada.
         inicioFeito: file.inicioFeito === true,
         rootDir: ROOT_DIR,
@@ -350,12 +352,25 @@ function loadConfig() {
     };
 }
 
+/* Preferências da tela Configurações: só estas chaves, cada uma com o seu tipo. O resto é descartado. */
+const PREFERENCIAS = { legenda: 'b', silencio: 'b', sfx: 'b', testes: 'b', voz: 's', formato: 's', idioma: 's' };
+function preferenciasValidas(o) {
+    const out = {};
+    if (!o || typeof o !== 'object') return out;
+    for (const [k, t] of Object.entries(PREFERENCIAS)) {
+        if (t === 'b' && typeof o[k] === 'boolean') out[k] = o[k];
+        else if (t === 's' && typeof o[k] === 'string' && o[k].length <= 40) out[k] = o[k];
+    }
+    return out;
+}
+
 function saveConfig(partial) {
     ensureDir(CONFIG_DIR);
     const cur = (() => { try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; } })();
     // Só persiste o que faz sentido guardar — nada de campos derivados.
     const { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes, team, piloto, grupo, inicioFeito } = { ...cur, ...partial };
-    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes, team, piloto, grupo, inicioFeito };
+    const preferencias = preferenciasValidas({ ...(cur.preferencias || {}), ...(partial.preferencias || {}) });
+    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes, team, piloto, grupo, inicioFeito, preferencias };
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
     return next;
 }

package/lib/diff.js

@@ -134,6 +134,8 @@ function desenhar(antes, depois, { prefixo = '', max = MAX_MOSTRADAS } = {}) {
     const out = [];
     let desenhadas = 0;
     let cortou = false;
+    let larguraFaixa = 20;
+    for (const bloco of blocos) for (const o of bloco) larguraFaixa = Math.max(larguraFaixa, 4 + 1 + 2 + Math.min(o.texto.length, 120) + 1);
 
     for (const bloco of blocos) {
         if (desenhadas >= max) { cortou = true; break; }
@@ -143,8 +145,16 @@ function desenhar(antes, depois, { prefixo = '', max = MAX_MOSTRADAS } = {}) {
             // removidas, o do antes. Sem número, "+ const x = 1" não diz onde.
             const n = String(o.b || o.a || '').padStart(4);
             const texto = o.texto.length > 120 ? o.texto.slice(0, 119) + '…' : o.texto;
-            if (o.tipo === '+') out.push(prefixo + c.dim(n) + ' ' + c.ok('+ ' + texto));
-            else if (o.tipo === '-') out.push(prefixo + c.dim(n) + ' ' + c.err('- ' + texto));
+            /* As linhas que entraram e saíram levam um FUNDO verde e vermelho até o fim
+               (o diff do OpenCode); as que ficaram, só o texto apagado. O fundo vale
+               a largura da linha mais comprida do bloco, para a faixa ficar reta. */
+            const faixa = (cor, fundo, sinal) => {
+                const corpo = `${n} ${sinal} ${texto}`;
+                return prefixo + fundo + c.dim(n) + fundo + ' ' + cor + sinal + ' ' + texto
+                    + ' '.repeat(Math.max(0, larguraFaixa - corpo.length)) + '\x1b[0m';
+            };
+            if (o.tipo === '+') out.push(faixa('\x1b[38;5;78m', '\x1b[48;5;22m', '+'));
+            else if (o.tipo === '-') out.push(faixa('\x1b[38;5;204m', '\x1b[48;5;52m', '-'));
             else out.push(prefixo + c.dim(n) + ' ' + c.dim('  ' + texto));
             desenhadas++;
         }

package/lib/motor/transcricao.js

@@ -0,0 +1,57 @@
+// Transcrição da fala do app (bug 3, 02/11): o renderer grava com MediaRecorder e manda o WAV; aqui ele vira texto
+// com o Whisper local que o produto já tem (voz/primo_voz/transcrever.py, no voz-venv). Sem provedor pago, sem rede.
+// Nunca toca som: só lê um arquivo.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+
+const PASTA_VOZ = path.join(__dirname, '..', '..', 'voz');
+const TETO_BYTES = 11 * 1024 * 1024;     // ~5 min de WAV 16 kHz mono (em base64 cabe no teto de 16 MB do WebSocket)
+const TEMPO_MS = 120000;
+
+/** O que falta para transcrever aqui, ou null se está tudo pronto. `py` vem de lib/plugin/voz.js (o venv do Primo ganha). */
+function faltaAlgo(py) {
+    if (!py) return { error: 'o modo voz precisa do Python 3, e não achei nenhum nesta máquina.', comoResolver: 'instale o Python 3 e rode `primocode doutor`' };
+    try { execFileSync(py, ['-c', 'import faster_whisper'], { stdio: ['ignore', 'pipe', 'pipe'], timeout: 20000 }); return null; } catch {
+        return { error: 'falta o Whisper local (faster-whisper), que transforma a sua fala em texto.', comoResolver: 'rode `primocode doutor` (ou abra o /voice no terminal uma vez, que ele instala)' };
+    }
+}
+
+/** `transcrever(wav, { python })` → { ok, texto } | { ok:false, error, comoResolver? }. Nunca rejeita. */
+function transcrever(wav, { python: py, idioma = 'pt', tempoMs = TEMPO_MS } = {}) {
+    py = py || require('../plugin/voz').python();
+    const falta = faltaAlgo(py);
+    if (falta) return Promise.resolve({ ok: false, ...falta });
+    return new Promise((resolve) => {
+        const p = spawn(py, ['-m', 'primo_voz.transcrever', 'arquivo', wav, idioma], { cwd: PASTA_VOZ, env: { ...process.env, PYTHONPATH: PASTA_VOZ } });
+        let fora = '', erro = '';
+        const t = setTimeout(() => { try { p.kill('SIGKILL'); } catch { /* já saiu */ } resolve({ ok: false, error: 'a transcrição demorou demais' }); }, tempoMs);
+        p.stdout.on('data', (d) => { fora += d; });
+        p.stderr.on('data', (d) => { erro += d; });
+        p.on('error', (e) => { clearTimeout(t); resolve({ ok: false, error: e.message }); });
+        p.on('close', () => {
+            clearTimeout(t);
+            try { const r = JSON.parse(fora.trim().split('\n').pop()); resolve(r.ok ? { ok: true, texto: String(r.texto || '') } : { ok: false, error: r.error || 'não consegui transcrever' }); }
+            catch { resolve({ ok: false, error: erro.trim().split('\n').pop() || 'o transcritor não respondeu' }); }
+        });
+    });
+}
+
+/** Grava o áudio (base64, WAV) num arquivo temporário, transcreve e apaga. `transcritor` troca o Whisper (teste). */
+async function transcreverBase64(audio, { pasta, transcritor = transcrever } = {}) {
+    if (typeof audio !== 'string' || !audio) return { ok: false, error: 'falta o áudio' };
+    const bytes = Buffer.from(audio, 'base64');
+    if (!bytes.length) return { ok: false, error: 'áudio vazio' };
+    if (bytes.length > TETO_BYTES) return { ok: false, error: 'áudio grande demais (máximo ~5 minutos)' };
+    if (bytes.subarray(0, 4).toString('latin1') !== 'RIFF') return { ok: false, error: 'o áudio precisa ser WAV' };
+    const dir = pasta || path.join(os.tmpdir(), 'primocode-voz');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const arq = path.join(dir, `fala-${Date.now()}-${process.pid}.wav`);
+    fs.writeFileSync(arq, bytes, { mode: 0o600 });
+    try { return await transcritor(arq); } finally { try { fs.rmSync(arq, { force: true }); } catch { /* sem arquivo */ } }
+}
+
+module.exports = { transcrever, transcreverBase64, faltaAlgo, TETO_BYTES };

package/lib/plugin/entregaveis/nucleo.js

@@ -103,7 +103,7 @@ function acharNavegador(env = process.env, existe = require('fs').existsSync) {
 function htmlParaPdf(htmlPath, pdfPath, { navegador = acharNavegador() } = {}) {
     if (!navegador) return { ok: false, erro: 'Chrome/Chromium não encontrado (defina PRIMO_CHROME)' };
     const { spawnSync } = require('child_process');
-    const r = spawnSync(navegador, ['--headless=new', '--disable-gpu', '--no-pdf-header-footer',
+    const r = spawnSync(navegador, ['--headless=new', '--use-mock-keychain', '--password-store=basic', '--disable-gpu', '--no-pdf-header-footer',
         `--print-to-pdf=${pdfPath}`, 'file://' + htmlPath], { encoding: 'utf8', timeout: 90000 });
     return require('fs').existsSync(pdfPath) ? { ok: true } : { ok: false, erro: (r.stderr || '').slice(-300) || 'PDF não saiu' };
 }
@@ -180,7 +180,7 @@ function htmlParaPngs(htmlPath, baseSemExt, n, w, h, { escala = 1, navegador = a
         const tmp = `${baseSemExt}.tmp-${i}.html`;
         const alvo = `${baseSemExt}-${String(i).padStart(2, '0')}.png`;
         fs.writeFileSync(tmp, html.replace('</head>', `<style>section:not(:nth-of-type(${i})){display:none!important}html,body{height:${h}px;overflow:hidden}</style></head>`));
-        spawnSync(navegador, ['--headless=new', '--disable-gpu', '--hide-scrollbars', `--force-device-scale-factor=${escala}`,
+        spawnSync(navegador, ['--headless=new', '--use-mock-keychain', '--password-store=basic', '--disable-gpu', '--hide-scrollbars', `--force-device-scale-factor=${escala}`,
             `--window-size=${w},${h}`, `--screenshot=${alvo}`, 'file://' + tmp], { encoding: 'utf8', timeout: 90000 });
         try { fs.unlinkSync(tmp); } catch {}
         if (fs.existsSync(alvo)) arquivos.push(alvo); else erro = `PNG ${i} não saiu`;

package/lib/plugin/estudio/gosto.js

@@ -519,6 +519,9 @@ function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0, inicio
         const token = crypto.randomBytes(16).toString('hex');
         let html;
         try { html = fs.readFileSync(path.join(__dirname, 'gosto', 'tela.html'), 'utf8'); } catch { return resolve({ ok: false, motivo: 'sem_tela' }); }
+        // No app do PrimoCode a tela abre num quadro (iframe) e o "Finalizar" (window.close) não faz nada ali: avisa a janela de fora
+        // para fechar o quadro. Entra na hora de servir, porque o gosto/tela.html é guardado sem mudança (test/kits-tela.test.js confere o sha1).
+        html = html.replace('</body>', "<script>document.addEventListener('click',function(e){var b=e.target.closest&&e.target.closest('#finalizar');if(b&&window.parent!==window)window.parent.postMessage('primocode:tela-fim','*');},true);</script></body>");
         // os vídeos que já estão no gosto: quem abre o /referencias de novo vê o que já trouxe (só o nome)
         const jaTem = ((ler(home) || {}).referencias || []).map((r) => String(r.nome || 'vídeo').slice(0, 80));
         const dados = JSON.stringify({ ESTILOS, GOSTEI, NAO_QUERO, INICIO: inicio === 'referencias' ? 'referencias' : 'carrossel', JA_TEM: jaTem }).replace(/</g, '\\u003c');

package/lib/plugin/estudio/kits/tela.html

@@ -380,9 +380,11 @@ function mandar(rota, corpo) {
 }
 function erro(msg) { const e = $('#erro'); e.hidden = !msg; e.textContent = msg || ''; }
 
+/* No app do PrimoCode a tela abre dentro de um quadro (iframe): avisa a janela de fora que acabou, pra ela fechar o quadro. */
+function avisarApp() { try { if (window.parent !== window) setTimeout(() => window.parent.postMessage('primocode:tela-fim', '*'), 1200); } catch { /* aberta solta no navegador */ } }
 function mostrar(n) {
   [1, 4].forEach((i) => { $('#passo' + i).hidden = i !== n; });
-  if (n === 4) { $('#titulo').textContent = 'Pronto. O PrimoCode já sabe o estilo.'; $('#sub').hidden = true; }
+  if (n === 4) { $('#titulo').textContent = 'Pronto. O PrimoCode já sabe o estilo.'; $('#sub').hidden = true; avisarApp(); }
   window.scrollTo({ top: 0, behavior: parar ? 'auto' : 'smooth' });
 }
 

package/lib/projetos-meta.js

@@ -6,7 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const ICONES = ['folder', 'film', 'palette', 'workflow', 'pen', 'home', 'shield', 'bell', 'sliders'];
+const ICONES = ['folder', 'film', 'palette', 'workflow', 'pen', 'home', 'shield', 'bell', 'sliders', 'code', 'rocket', 'cake', 'store', 'clapperboard', 'megaphone', 'graduation-cap', 'heart', 'camera', 'music'];
 const COR_PADRAO = '#22d3ee';
 const hexOk = (h) => /^#[0-9a-f]{6}$/i.test(String(h || ''));
 const cfg = () => require('./config/config');
@@ -36,6 +36,21 @@ function ramoGit(dir) {
     } catch { return { git: false, ramo: '' }; }
 }
 
+/* O "dono/repo" do remoto origin, lido do .git/config (sem rodar o git). Vazio se não há. */
+function remotoGit(dir) {
+    try {
+        const cfg = fs.readFileSync(path.join(dir, '.git', 'config'), 'utf8');
+        const m = /\[remote "origin"\][^\[]*?url\s*=\s*(\S+)/.exec(cfg);
+        const r = m && /[:/]([\w.-]+\/[\w.-]+?)(?:\.git)?$/.exec(m[1]);
+        return r ? r[1] : '';
+    } catch { return ''; }
+}
+
+/* Quantos itens (arquivos e pastas, sem os ocultos) o projeto tem na raiz, e quando mexeram nele por último. */
+function conteudo(dir) {
+    try { return { itens: fs.readdirSync(dir).filter((n) => !n.startsWith('.')).length, atualizado: fs.statSync(dir).mtimeMs }; } catch { return { itens: 0, atualizado: null }; }
+}
+
 function resumo(id) {
     const dir = path.join(raiz(), id);
     const m = lerMeta(dir);
@@ -43,12 +58,14 @@ function resumo(id) {
         id, nome: m.nome || id, descricao: m.descricao || '',
         icone: ICONES.includes(m.icone) ? m.icone : 'folder', cor: hexOk(m.cor) ? m.cor : COR_PADRAO,
         caminho: dir, arquivado: !!m.arquivado, criado: m.criado || null,
-        ...ramoGit(dir),
+        ...ramoGit(dir), remoto: remotoGit(dir), ...conteudo(dir),
     };
 }
 
 function listar({ arquivados = false } = {}) {
-    return cfg().listProjects().map(resumo).filter((p) => arquivados || !p.arquivado);
+    /* O mais recente primeiro (como a lista da barra lateral); empate por nome. */
+    return cfg().listProjects().map(resumo).filter((p) => arquivados || !p.arquivado)
+        .sort((a, b) => String(b.criado || '').localeCompare(String(a.criado || '')) || a.nome.localeCompare(b.nome));
 }
 
 function limpar(c, { criando = false } = {}) {

package/lib/session/runner/act.js

@@ -246,6 +246,17 @@ function ident(profundidade) {
  * duas versões do texto, que o `limparParaOModelo` apaga antes de a conversa
  * seguir. Sem essa limpeza, cada edição mandaria o arquivo inteiro de volta
  * ao modelo — que acabou de escrevê-lo e não aprende nada relendo. */
+/* +N −M de uma escrita ou edição: o diff de verdade (linhas que entraram e saíram). Arquivo
+   novo conta todas as linhas como entradas. Sem as duas versões nem a contagem, null. */
+function contarMudanca(result) {
+    if (!result) return null;
+    if (typeof result._antes === 'string' && typeof result._depois === 'string') {
+        try { return diff.contar(diff.operacoes(result._antes, result._depois)); } catch { return null; }
+    }
+    if (result.created && Number.isFinite(result.linhas)) return { mais: result.linhas, menos: 0 };
+    return null;
+}
+
 function mostrarDiff(result, profundidade) {
     if (!result || typeof result._antes !== 'string' || typeof result._depois !== 'string') return;
     const bloco = diff.desenhar(result._antes, result._depois, {
@@ -287,17 +298,24 @@ function logResult(kind, result, profundidade) {
     }
 
     switch (kind) {
-        case 'write_file':
-            console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`));
+        case 'write_file': {
+            const k = contarMudanca(result);
+            if (k) require('../../tui/ui').registrarArquivo(result.path, k.mais, k.menos);
+            console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`)
+                + (k ? c.muted(' · ') + c.ok(`+${k.mais}`) + ' ' + c.err(`−${k.menos}`) : ''));
             // Reescrever arquivo que já existia apaga o que estava lá. O
             // número de bytes não conta isso; o bloco embaixo conta.
             mostrarDiff(result, profundidade);
             return;
+        }
         case 'edit_file':
         case 'multi_edit': {
             const delta = result.linhasDepois - result.linhasAntes;
             const sinal = delta > 0 ? c.ok(`+${delta}`) : delta < 0 ? c.err(`${delta}`) : c.muted('±0');
-            console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas'));
+            const k = contarMudanca(result);
+            if (k) require('../../tui/ui').registrarArquivo(result.path, k.mais, k.menos);
+            console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas')
+                + (k ? c.muted(' · ') + c.ok(`+${k.mais}`) + ' ' + c.err(`−${k.menos}`) : ''));
             mostrarDiff(result, profundidade);
             return;
         }
@@ -342,6 +360,7 @@ function logResult(kind, result, profundidade) {
             return;
         }
         case 'write_todos': {
+            require('../../tui/ui').estadoSessao.todos = result.todos || [];
             const marca = { completed: c.ok('✔'), in_progress: c.brand('▶'), pending: c.dim('○') };
             for (const t of result.todos || []) {
                 const texto = t.status === 'completed' ? c.dim(t.content) : c.white(t.content);
@@ -2287,7 +2306,7 @@ async function runActInterno(userPrompt, opts) {
     // arquivo de verdade — a memória era descartada nesse caso, sempre.
     // 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)) {
+    if (!subagent && temPasta && pastaAtual && require('path').resolve(pastaAtual) !== require('path').resolve(cfg.ROOT_DIR)) {
         cfg.appendProjectMemory(pastaAtual, passagemDaParada || `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
     }
 

package/lib/tool/tools.js

@@ -688,6 +688,7 @@ async function despachar(name, args, ctx) {
                     ok: true, created,
                     path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
                     bytes: content.length,
+                    linhas: content.split('\n').length,
                     ...(created ? {} : { _antes: antes, _depois: content }),
                 };
             }