primocode 11.1.0 → 11.3.0

package/lib/app-server/websocket.js

@@ -0,0 +1,87 @@
+// WebSocket mínimo (RFC 6455) feito na mão: handshake, frames de texto,
+// ping/pong e close. Sem pacote. Só o que o app-server precisa.
+'use strict';
+
+const crypto = require('crypto');
+
+const GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+const MAX_PAYLOAD = 16 * 1024 * 1024;
+
+const aceite = (chave) => crypto.createHash('sha1').update(chave + GUID).digest('base64');
+
+/* Frame do servidor (nunca mascarado). */
+function frame(opcode, payload) {
+    const corpo = Buffer.isBuffer(payload) ? payload : Buffer.from(String(payload || ''), 'utf8');
+    const n = corpo.length;
+    let cab;
+    if (n < 126) cab = Buffer.from([0x80 | opcode, n]);
+    else if (n < 65536) { cab = Buffer.alloc(4); cab[0] = 0x80 | opcode; cab[1] = 126; cab.writeUInt16BE(n, 2); }
+    else { cab = Buffer.alloc(10); cab[0] = 0x80 | opcode; cab[1] = 127; cab.writeBigUInt64BE(BigInt(n), 2); }
+    return Buffer.concat([cab, corpo]);
+}
+
+/* Responde ao upgrade. Devolve a conexão { enviar, fechar }; o resto vem por callbacks. */
+function aceitar(req, socket, { aoTexto, aoFechar }) {
+    const chave = req.headers['sec-websocket-key'];
+    socket.write('HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n'
+        + `Sec-WebSocket-Accept: ${aceite(chave)}\r\n\r\n`);
+    socket.setNoDelay(true);
+
+    let buf = Buffer.alloc(0);
+    let fragmentos = [];
+    let fechado = false;
+
+    const fechar = (codigo = 1000) => {
+        if (fechado) return;
+        fechado = true;
+        const c = Buffer.alloc(2); c.writeUInt16BE(codigo, 0);
+        try { socket.write(frame(0x8, c)); } catch { /* socket já morreu */ }
+        try { socket.end(); } catch { /* idem */ }
+        if (aoFechar) aoFechar();
+    };
+    const enviar = (texto) => { if (!fechado) { try { socket.write(frame(0x1, texto)); } catch { /* idem */ } } };
+
+    const processar = () => {
+        for (;;) {
+            if (buf.length < 2) return;
+            const fin = (buf[0] & 0x80) !== 0;
+            const opcode = buf[0] & 0x0f;
+            const mascarado = (buf[1] & 0x80) !== 0;
+            let n = buf[1] & 0x7f;
+            let pos = 2;
+            if (n === 126) { if (buf.length < 4) return; n = buf.readUInt16BE(2); pos = 4; }
+            else if (n === 127) {
+                if (buf.length < 10) return;
+                const grande = buf.readBigUInt64BE(2);
+                if (grande > BigInt(MAX_PAYLOAD)) return fechar(1009);
+                n = Number(grande); pos = 10;
+            }
+            if (n > MAX_PAYLOAD) return fechar(1009);
+            // Cliente sempre mascara (RFC): sem máscara é protocolo quebrado.
+            if (!mascarado) return fechar(1002);
+            if (buf.length < pos + 4 + n) return;
+            const mascara = buf.subarray(pos, pos + 4);
+            const dados = Buffer.from(buf.subarray(pos + 4, pos + 4 + n));
+            for (let i = 0; i < n; i++) dados[i] ^= mascara[i % 4];
+            buf = buf.subarray(pos + 4 + n);
+
+            if (opcode === 0x8) return fechar(1000);
+            if (opcode === 0x9) { try { socket.write(frame(0xA, dados)); } catch { /* idem */ } continue; }
+            if (opcode === 0xA) continue;
+            if (opcode === 0x1 || opcode === 0x0) {
+                if (opcode === 0x1) fragmentos = [];
+                fragmentos.push(dados);
+                if (fin) { const t = Buffer.concat(fragmentos).toString('utf8'); fragmentos = []; aoTexto(t); }
+                continue;
+            }
+            return fechar(1003); // binário e o resto: não suportado
+        }
+    };
+
+    socket.on('data', (d) => { buf = Buffer.concat([buf, d]); processar(); });
+    socket.on('close', () => { if (!fechado) { fechado = true; if (aoFechar) aoFechar(); } });
+    socket.on('error', () => { /* o close vem em seguida */ });
+    return { enviar, fechar };
+}
+
+module.exports = { aceitar, frame, aceite, GUID };

package/lib/avisos.js

@@ -0,0 +1,65 @@
+// Avisos e fila de aprovação: ~/.primocode/avisos.json (docs/estrutura.md, seções 7 e 9). Node puro.
+// tipo: "aviso" (o agente terminou algo, ou deu erro) | "aprovacao" (espera sim ou não).
+// estado: "novo" → "lido"; aprovação: "pendente" → "resolvido".
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MAX = 200;
+const arquivo = (a) => a || process.env.PRIMOCODE_AVISOS || path.join(os.homedir(), '.primocode', 'avisos.json');
+
+function ler({ arquivo: a } = {}) {
+    try { const l = JSON.parse(fs.readFileSync(arquivo(a), 'utf8')); return Array.isArray(l) ? l : []; } catch { return []; }
+}
+function gravar(lista, a) {
+    const f = arquivo(a);
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    fs.writeFileSync(f, JSON.stringify(lista.slice(0, MAX), null, 1), { mode: 0o600 });
+}
+
+function criar(dados, { arquivo: a } = {}) {
+    const aprov = dados.tipo === 'aprovacao';
+    const av = {
+        id: `n${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`,
+        tipo: aprov ? 'aprovacao' : 'aviso',
+        estado: aprov ? 'pendente' : 'novo',
+        nivel: dados.nivel === 'erro' ? 'erro' : 'ok',
+        texto: String(dados.texto || '').slice(0, 600),
+        detalhe: dados.detalhe ? String(dados.detalhe).slice(0, 300) : null,
+        agente: dados.agente || null, thread: dados.thread || null, aprovacao: dados.aprovacao || null,
+        criado: Date.now(),
+    };
+    gravar([av, ...ler({ arquivo: a })], a);
+    return av;
+}
+
+const contagem = (l) => ({
+    naoLidos: l.filter((x) => x.estado === 'novo').length,
+    praAprovar: l.filter((x) => x.estado === 'pendente').length,
+});
+
+function listar({ arquivo: a } = {}) { const l = ler({ arquivo: a }); return { avisos: l, ...contagem(l) }; }
+
+/* Marca como lido um aviso (id) ou todos. Aprovação pendente não some ao ler: só ao responder. */
+function marcarLido({ id, todos } = {}, { arquivo: a } = {}) {
+    const l = ler({ arquivo: a });
+    let achou = false;
+    for (const x of l) if ((todos || x.id === id) && x.estado === 'novo') { x.estado = 'lido'; achou = true; }
+    if (!todos && !l.some((x) => x.id === id)) throw new Error(`não achei o aviso ${id}`);
+    if (achou) gravar(l, a);
+    return { avisos: l, ...contagem(l) };
+}
+
+/* A aprovação foi respondida (pelo cartão ou pelo aviso). */
+function resolverAprovacao(aprovacaoId, resposta, { arquivo: a } = {}) {
+    const l = ler({ arquivo: a });
+    const x = l.find((n) => n.tipo === 'aprovacao' && n.aprovacao === aprovacaoId && n.estado === 'pendente');
+    if (!x) return null;
+    x.estado = 'resolvido'; x.resposta = resposta || null;
+    gravar(l, a);
+    return x;
+}
+
+module.exports = { ler, criar, listar, marcarLido, resolverAprovacao, contagem };

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');
@@ -242,6 +243,8 @@ const SLASH_COMANDOS = [
     ['/version', 'versão'],
     ['/exit', 'sair'],
 ];
+// A CLI nova (lib/cli-nova.js): /estudio /agentes /piloto /avisos /buscar entram no menu e no autopreenchimento.
+SLASH_COMANDOS.splice(Math.max(0, SLASH_COMANDOS.findIndex(([n]) => n === '/marca')), 0, ...require('../cli-nova.js').SLASH_NOVOS);
 
 /* /api: a chave da própria pessoa — lib/cli/comando-api.js. */
 const comandoApi = require('./comando-api.js').criar({ rl: () => rl, ask: (...a) => ask(...a), askSecret: (...a) => askSecret(...a) });
@@ -440,9 +443,12 @@ function barraDeStatus() {
     // Modelo que respondeu · contexto · tokens de hoje (os mesmos do /usage) — lib/cli/statusline.js.
     const SL = require('./statusline.js');
     direita.push(...SL.partes({ modelo: SL.modelo(), ctxPct: uso.pct, tokensHoje: SL.tokensDeHoje(), c }));
-    direita.push(state.trabalhando && rl && rl.ocupado
+    const aprovar = require('../cli-nova.js').praAprovar();
+    if (aprovar) direita.push(c.warn(`${aprovar} pra aprovar`));
+    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. */
@@ -451,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
@@ -464,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) : ''),
@@ -486,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() {
@@ -503,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
@@ -918,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) {
@@ -1190,7 +1342,10 @@ async function sendPrompt(userText, { digitado = false } = {}) {
         const m = state.mode === 'auto' ? (state.modoEfetivo || 'auto') : state.mode;
         if (!state.semTerminal) {
             console.log('\n  ' + `${COR_MODO[m] || COR_MODO.auto}▣${c.reset} ` + c.white(NOME_MODO[m] || m)
-                + c.dim(` · ${effort.normalizar(state.config.effort)} · ${((Date.now() - inicio) / 1000).toFixed(1)}s`) + '\n');
+                + c.dim(` · ${effort.normalizar(state.config.effort)} · ${((Date.now() - inicio) / 1000).toFixed(1)}s`));
+            const nAcoes = require('../cli-nova.js').zerar();
+            if (nAcoes) console.log(require('../cli-nova.js').fecho({ segundos: (Date.now() - inicio) / 1000, acoes: nAcoes }, { c }));
+            console.log('');
             // O que o agente deixou de pé (run_background), com o endereço pra abrir.
             const rodape = require('../fundo.js').linhasRodape(require('../fundo.js').listar(), c);
             if (rodape.length) console.log(rodape.join('\n') + '\n');
@@ -1354,6 +1509,7 @@ async function enviarPedido(userText) {
                     i === 0 ? require('../plugin/estudio/referencias.js').instrucao() : '',
                     // As imagens do pedido (arrastadas ou coladas): guardadas para o Estúdio importar, e ditas ao agente.
                     i === 0 ? (() => { const R = require('../plugin/estudio/referencias.js'); return R.instrucaoDasImagens(R.guardarImagens(R.imagensNoTexto(userText))); })() : '',
+                    i === 0 ? require('../cli-nova.js').instrucaoDeAgentes(userText).texto : '',
                     i === 0 ? plan.notaOutraPasta || '' : ''].filter(Boolean).join('\n\n'),
             });
 
@@ -2113,7 +2269,18 @@ async function handleSlash(text) {
            listava os nomes, em ordem alfabética, e quem procurava "o de ontem"
            tinha de abrir pasta por pasta. Agora vem do mais recente, com
            quando mexeu e o tamanho, e um número para entrar. */
+        case 'estudio': case 'agentes': case 'piloto': case 'avisos': case 'buscar': {
+            const r = require('../cli-nova.js').COMANDOS[nome](rest, { c, dir: process.env.PRIMOCODE_AGENTES });
+            for (const l of r.linhas) console.log(l);
+            if (r.pedido) await sendPrompt(`${r.instrucao}\n\nPEDIDO: ${r.pedido}`);
+            break;
+        }
+
         case 'projects': {
+            if (/^(criar|novo|editar|arquivar)\b/.test(rest)) {
+                for (const l of require('../cli-nova.js').projetos(rest, { c }).linhas) console.log(l);
+                break;
+            }
             const lista = extra.listarProjetos(cfg.ROOT_DIR);
             const numero = /^\d+$/.test(rest) ? Number(rest) : 0;
             if (!rest || (numero && cmd.toLowerCase() === 'projetos') || (numero && numero <= lista.length)) {
@@ -2990,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
@@ -3774,6 +3944,14 @@ async function main() {
     if (process.argv[2] === 'marca') {
         process.exit(await require('../plugin/marca-kit.js').main(process.argv.slice(3)));
     }
+    if (process.argv[2] === 'app') {
+        const r = require('../cli-nova.js').app();
+        console.log(r.texto); process.exit(r.ok ? 0 : 1);
+    }
+    /* `primocode server`: o app-server local (lib/app-server/). stdout é do JSON-RPC. */
+    if (process.argv[2] === 'server') {
+        process.exit(await require('../app-server/cli.js').main(process.argv.slice(3)));
+    }
     if (process.argv[2] === 'mcp') {
         process.exit(await require('../mcp/mcp.js').main(process.argv.slice(3)));
     }
@@ -3898,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) {
@@ -3919,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);
@@ -3927,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). */
@@ -3960,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) {