primocode 11.1.0 → 11.3.0

package/lib/cli-nova.js

@@ -0,0 +1,237 @@
+// A CLI nova (docs/estrutura.md, seção 5): comandos de barra /estudio /projetos /agentes /piloto /avisos /buscar,
+// `primocode app`, @agente no prompt, células com os verbos do PrimoCode e a status line.
+// Só COMPÕE os módulos que o app já usa (projetos-meta, agentes, avisos, estudio/criar, estudio/historico,
+// config): nenhuma regra é duplicada aqui. Cada comando devolve linhas de texto; quem imprime é a CLI. Node puro.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const cfg = () => require('./config/config');
+const sem = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+const sim = (v) => /^(on|liga|ligar|ligado|sim|s|1|true)$/i.test(String(v || ''));
+const nao = (v) => /^(off|desliga|desligar|desligado|nao|não|n|0|false)$/i.test(String(v || ''));
+const cor = (c, nome) => (c && c[nome]) || ((t) => t);
+
+/* ── Células: o molde do Codex CLI com os verbos do PrimoCode ───────────────── */
+const VERBOS = [
+    [/^(read_file|list_dir|list_files|glob|grep|search_files|tree|ler_arquivo|listar)/, 'Explorou'],
+    [/^(web_search|search_web|pesquisar|buscar_web)/, 'Pesquisou na web por'],
+    [/^(run_command|bash|shell|run|exec)/, 'Rodou'],
+    [/^(edit_file|apply_patch|str_replace|replace_in_file|editar)/, 'Editou'],
+    [/^(write_file|create_file|estudio_criar|criar_arquivo)/, 'Criou'],
+    [/^(spawn_agent|mcp_|call_agent|chamar)/, 'Chamou'],
+];
+const verboDe = (nome) => { const v = VERBOS.find(([re]) => re.test(String(nome || ''))); return v ? v[1] : 'Chamou'; };
+
+/** `• Verbo alvo`; Editou ganha (+N −M). Minimizada = só a primeira linha; aberta traz o detalhe recuado. */
+function celula(item, { c, aberta = false } = {}) {
+    const dim = cor(c, 'dim'); const brand = cor(c, 'brand');
+    const verbo = item.verbo || verboDe(item.nome);
+    let l = `${brand('•')} ${verbo}${item.alvo ? ' ' + item.alvo : ''}`;
+    if (verbo === 'Editou' && (item.mais != null || item.menos != null)) l += dim(` (+${item.mais || 0} −${item.menos || 0})`);
+    const linhas = [l];
+    if (aberta && item.detalhe) for (const d of String(item.detalhe).split('\n').slice(0, 12)) linhas.push(dim('    ' + d));
+    return linhas;
+}
+function plano(passos, { c } = {}) {
+    const ok = cor(c, 'ok'); const dim = cor(c, 'dim');
+    return passos.map((p) => (p.feito ? `  ${ok('✔')} ${dim(p.texto)}` : `  □ ${p.texto}`));
+}
+const fecho = ({ segundos = 0, acoes = 0 } = {}, { c } = {}) =>
+    cor(c, 'dim')(`  Trabalhou por ${Math.max(0, Math.round(segundos))}s • ${acoes} ${acoes === 1 ? 'ação' : 'ações'}`);
+const interrompida = ({ c } = {}) => cor(c, 'warn')('  ■ Conversa interrompida');
+
+/* Conta as ações do turno (a tela do terminal chama contar a cada item `acao`). */
+const turno = { acoes: 0 };
+const contar = () => { turno.acoes++; };
+const zerar = () => { const n = turno.acoes; turno.acoes = 0; return n; };
+
+/* ── Status line ────────────────────────────────────────────────────────────── */
+const NOMES_ESFORCO = { low: 'Leve', medium: 'Médio', high: 'Alto', ultra: 'Ultra', ultracode: 'Ultra' };
+const tok = (n) => (n >= 1000 ? `${Math.round(n / 1000)}k` : String(n || 0));
+
+/** `~/primocode/<projeto> · Alto · 34% ctx · 28k tok hoje · ● trabalhando · N pra aprovar`. ctx laranja ≥70%, vermelho ≥100%. */
+function statusLinha(e = {}, { c } = {}) {
+    const dim = cor(c, 'dim'); const sep = dim(' · ');
+    const p = [];
+    p.push(cor(c, 'brandDim')(e.pasta || '~/primocode'));
+    p.push(cor(c, 'white')(NOMES_ESFORCO[String(e.esforco || '').toLowerCase()] || e.esforco || 'Alto'));
+    if (e.ctxPct != null) p.push(e.ctxPct >= 100 ? cor(c, 'err')(`${e.ctxPct}% ctx`) : e.ctxPct >= 70 ? cor(c, 'warn')(`${e.ctxPct}% ctx`) : dim(`${e.ctxPct}% ctx`));
+    if (e.tokensHoje) p.push(dim(`${tok(e.tokensHoje)} tok hoje`));
+    if (e.trabalhando) p.push(cor(c, 'warn')('● trabalhando'));
+    if (e.praAprovar) p.push(cor(c, 'warn')(`${e.praAprovar} pra aprovar`));
+    return p.join(sep);
+}
+const praAprovar = () => { try { return require('./avisos').contagem(require('./avisos').ler()).praAprovar; } catch { return 0; } };
+
+/* ── @agente no prompt ──────────────────────────────────────────────────────── */
+/** O texto que entra como instrução do turno: o agente citado (mesmo desligado) vira chamada, os ligados vão de cardápio. */
+function instrucaoDeAgentes(texto, { dir } = {}) {
+    try { return require('./agentes-pessoais').instrucao(texto, [], { dir }); } catch { return { texto: '', chamados: [] }; }
+}
+/** Nomes do `@` na hora de digitar: agentes primeiro (com o ofício), arquivos depois. */
+function completarArroba(prefixo, { projeto, dir } = {}) {
+    const q = sem(String(prefixo || '').replace(/^@/, ''));
+    const ags = require('./agentes-pessoais').listar({ dir }).filter((a) => sem(a.nome).startsWith(q))
+        .map((a) => ({ tipo: 'agente', valor: '@' + a.nome, descricao: a.descricao || a.oficio.slice(0, 60) }));
+    let arqs = [];
+    if (projeto) {
+        try {
+            arqs = fs.readdirSync(projeto, { withFileTypes: true }).filter((d) => !d.name.startsWith('.') && sem(d.name).startsWith(q))
+                .map((d) => ({ tipo: d.isDirectory() ? 'pasta' : 'arquivo', valor: '@' + d.name + (d.isDirectory() ? '/' : ''), descricao: '' }));
+        } catch { /* sem projeto */ }
+    }
+    return ags.concat(arqs.slice(0, 20));
+}
+
+/* ── Comandos de barra ──────────────────────────────────────────────────────── */
+const TIPOS_ESTUDIO = [['slides', 'apresentação em PDF'], ['video', 'vídeo curto vertical'], ['motion', 'animação de motion'], ['carrossel', 'carrossel (sem receita no Estúdio ainda)'], ['anuncio', 'anúncio de 15 s'], ['abertura', 'abertura de canal de 5 s']];
+
+/** `/estudio [tipo] [briefing]` → { linhas, pedido?, tipo? }. Com tipo e briefing, devolve o `pedido` para a sessão mandar ao motor. */
+function estudio(rest, { c } = {}) {
+    const { QUADRADOS, instrucaoDoTipo } = require('./plugin/estudio/criar');
+    const [t0, ...r] = String(rest || '').trim().split(/\s+/).filter(Boolean);
+    const tipo = sem(t0).replace(/^v[ií]deo$/, 'video');
+    const linhas = [];
+    if (!t0) {
+        linhas.push(cor(c, 'white')('O que vamos criar?'));
+        for (const [n, d] of TIPOS_ESTUDIO) linhas.push(`  ${cor(c, 'brand')(n.padEnd(10))}${cor(c, 'muted')(d)}`);
+        linhas.push(cor(c, 'dim')('  /estudio <tipo> [o que criar]'));
+        return { linhas };
+    }
+    if (!TIPOS_ESTUDIO.some(([n]) => n === tipo) && !QUADRADOS[tipo]) return { linhas: [cor(c, 'err')(`Tipo "${t0}" não existe. Use: ${TIPOS_ESTUDIO.map(([n]) => n).join(', ')}.`)], erro: true };
+    if (tipo === 'carrossel') return { linhas: [cor(c, 'warn')('Carrossel ainda não tem receita no Estúdio. Descreva como slides ou peça direto na conversa.')], erro: true };
+    const briefing = r.join(' ');
+    if (!briefing) return { linhas: [cor(c, 'white')(`O que vamos criar em ${tipo}?`), cor(c, 'dim')(`  /estudio ${tipo} <descrição do que criar>`)], tipo };
+    return { linhas: [], tipo, pedido: briefing, instrucao: instrucaoDoTipo(tipo) };
+}
+
+/** `/projetos`: lista · `criar <nome>` · `editar <id> nome=… icone=… cor=… descricao=…` · `arquivar <id>`. Mesmo módulo do app. */
+function projetos(rest, { c } = {}) {
+    const P = require('./projetos-meta');
+    const [op, ...r] = String(rest || '').trim().split(/\s+/).filter(Boolean);
+    try {
+        if (op === 'criar' || op === 'novo') { const p = P.criar({ nome: r.join(' ') }); return { linhas: [cor(c, 'ok')(`Projeto criado: ${p.nome}`) + cor(c, 'muted')(`  (${p.caminho})`)], projeto: p }; }
+        if (op === 'editar') {
+            const [id, ...kv] = r; const m = {};
+            for (const x of kv) { const i = x.indexOf('='); if (i > 0) m[x.slice(0, i)] = x.slice(i + 1); }
+            const p = P.atualizar(id, m);
+            return { linhas: [cor(c, 'ok')(`Projeto atualizado: ${p.nome} · ${p.icone} · ${p.cor}`)], projeto: p };
+        }
+        if (op === 'arquivar') { const x = P.arquivar(r[0]); return { linhas: [cor(c, 'ok')(`Arquivado ${x.id} (os arquivos ficam).`)] }; }
+    } catch (e) { return { linhas: [cor(c, 'err')(e.message)], erro: true }; }
+    const l = P.listar();
+    if (!l.length) return { linhas: [cor(c, 'muted')('Nenhum projeto ainda.')] };
+    return { linhas: l.map((p, i) => `  ${String(i + 1).padStart(2)}  ${cor(c, 'white')(p.nome.padEnd(24))}${cor(c, 'dim')(`${p.icone} ${p.cor}${p.descricao ? ' · ' + p.descricao : ''}`)}`), lista: l };
+}
+
+/** `/agentes`: lista · ligar|desligar <nome> · criar <nome> | <descrição> | <ofício> · apagar <nome>. */
+function agentes(rest, { c, dir } = {}) {
+    const A = require('./agentes-pessoais');
+    const [op, ...r] = String(rest || '').trim().split(/\s+/).filter(Boolean);
+    try {
+        if (op === 'ligar' || op === 'desligar') { const a = A.alternar(r[0], op === 'ligar', { dir }); return { linhas: [cor(c, 'ok')(`@${a.nome} ${a.ligado ? 'ligado' : 'desligado'}`)] }; }
+        if (op === 'apagar') { const x = A.apagar(r[0], { dir }); return { linhas: [cor(c, 'ok')(`@${x.nome} apagado`)] }; }
+        if (op === 'criar') {
+            const [nome, descricao, oficio] = r.join(' ').split('|').map((s) => s.trim());
+            const a = A.criar({ nome, descricao: descricao || '', oficio: oficio || descricao || '' }, { dir });
+            return { linhas: [cor(c, 'ok')(`@${a.nome} criado`) + cor(c, 'muted')('  (desligado: /agentes ligar ' + a.nome + ')')] };
+        }
+    } catch (e) { return { linhas: [cor(c, 'err')(e.message)], erro: true }; }
+    const l = A.listar({ dir });
+    if (!l.length) return { linhas: [cor(c, 'muted')('Nenhum agente. Crie: /agentes criar <nome> | <o que faz> | <ofício>')] };
+    return { linhas: l.map((a) => `  ${a.ligado ? cor(c, 'ok')('●') : cor(c, 'dim')('○')} ${cor(c, 'white')('@' + a.nome.padEnd(16))}${cor(c, 'dim')(a.descricao || a.oficio.slice(0, 60))}`), lista: l };
+}
+
+/** `/piloto [on|off] [grupo]`: grava `piloto` e `grupo` na config; quem roda o ciclo é o app-server (lib/piloto.js). */
+function piloto(rest, { c } = {}) {
+    const ps = String(rest || '').trim().split(/\s+/).filter(Boolean);
+    const mudar = {};
+    for (const p of ps) { if (sim(p)) mudar.piloto = true; else if (nao(p)) mudar.piloto = false; else if (/^grupo$/i.test(p)) mudar.grupo = true; else if (/^solo$/i.test(p)) mudar.grupo = false; }
+    if (Object.keys(mudar).length) cfg().saveConfig(mudar);
+    const e = cfg().loadConfig();
+    const ligados = require('./agentes-pessoais').listar().filter((a) => a.ligado).length;
+    return { linhas: [
+        `${e.piloto === true ? cor(c, 'ok')('● Piloto ligado') : cor(c, 'dim')('○ Piloto desligado')}${e.grupo === true ? cor(c, 'muted')(' · em grupo') : ''}  ${cor(c, 'muted')(`${ligados} agente${ligados === 1 ? '' : 's'} ligado${ligados === 1 ? '' : 's'}`)}`,
+        cor(c, 'dim')('  O ciclo roda no app-server (primocode app/server); aqui só liga e desliga.'),
+    ], ligado: e.piloto === true, grupo: e.grupo === true };
+}
+
+/** `/avisos`: a fila. `a <n>` aprova, `r <n>` recusa, `ler [n|todos]` marca lido. */
+function avisos(rest, { c, arquivo } = {}) {
+    const V = require('./avisos');
+    const [op, n] = String(rest || '').trim().split(/\s+/).filter(Boolean);
+    const arq = arquivo ? { arquivo } : {};
+    const lista = () => V.ler(arq).filter((x) => x.estado === 'pendente' || x.estado === 'novo');
+    try {
+        if (op === 'a' || op === 'r') {
+            const x = lista()[Number(n) - 1];
+            if (!x || x.tipo !== 'aprovacao') return { linhas: [cor(c, 'err')('Escolha o número de uma aprovação pendente: /avisos a 1')], erro: true };
+            V.resolverAprovacao(x.aprovacao, op === 'r' ? 'nao' : 'agora', arq);
+            return { linhas: [cor(c, 'ok')(`${op === 'r' ? 'Recusado' : 'Aprovado'}: ${x.texto}`)] };
+        }
+        if (op === 'ler') {
+            const x = n && n !== 'todos' ? lista()[Number(n) - 1] : null;
+            V.marcarLido(n === 'todos' || !n ? { todos: true } : { id: x && x.id }, arq);
+            return { linhas: [cor(c, 'ok')('Marcado como lido.')] };
+        }
+    } catch (e) { return { linhas: [cor(c, 'err')(e.message)], erro: true }; }
+    const l = lista();
+    const k = V.contagem(V.ler(arq));
+    if (!l.length) return { linhas: [cor(c, 'muted')('Nada pra ver. Fila vazia.')] };
+    return { linhas: [
+        ...l.map((x, i) => `  ${String(i + 1).padStart(2)}  ${x.tipo === 'aprovacao' ? cor(c, 'warn')('aprovar') : cor(c, x.nivel === 'erro' ? 'err' : 'ok')('aviso  ')}  ${x.texto}${x.agente ? cor(c, 'dim')(' · @' + x.agente) : ''}`),
+        cor(c, 'dim')(`  ${k.praAprovar} pra aprovar · ${k.naoLidos} não lidos · a <n> aprova · r <n> recusa · ler [n|todos]`),
+    ], lista: l };
+}
+
+/** `/buscar <texto>`: projetos, agentes, vídeos/slides do Estúdio e conversas salvas. */
+function buscar(rest, { c, dir } = {}) {
+    const q = sem(rest).trim();
+    if (!q) return { linhas: [cor(c, 'dim')('Uso: /buscar <texto>  (projetos, agentes, vídeos, conversas)')], erro: true };
+    const achei = (txt) => sem(txt).includes(q);
+    const out = [];
+    const sec = (t, itens) => { if (itens.length) { out.push(cor(c, 'white')(t)); out.push(...itens.slice(0, 8)); } };
+    const tenta = (f, d) => { try { return f(); } catch { return d; } };
+    sec('Projetos', tenta(() => require('./projetos-meta').listar(), []).filter((p) => achei(`${p.nome} ${p.descricao}`)).map((p) => `  ${p.nome}${cor(c, 'dim')('  ' + p.caminho)}`));
+    sec('Agentes', tenta(() => require('./agentes-pessoais').listar({ dir }), []).filter((a) => achei(`${a.nome} ${a.descricao} ${a.oficio}`)).map((a) => `  @${a.nome}${cor(c, 'dim')('  ' + (a.descricao || ''))}`));
+    sec('Vídeos e slides', tenta(() => require('./plugin/estudio/historico').historico({ busca: rest, limite: 8 }).itens, []).map((i) => `  ${i.titulo}${cor(c, 'dim')('  ' + (i.principal || i.pasta))}`));
+    const pt = path.join(os.homedir(), '.primocode', 'threads');
+    sec('Conversas', tenta(() => fs.readdirSync(pt).filter((n) => n.endsWith('.json')).map((n) => JSON.parse(fs.readFileSync(path.join(pt, n), 'utf8'))), [])
+        .filter((t) => !t.arquivada && achei(t.titulo)).map((t) => `  ${t.titulo}${cor(c, 'dim')('  ' + t.id)}`));
+    return { linhas: out.length ? out : [cor(c, 'muted')(`Nada achado para "${rest}".`)] };
+}
+
+const SLASH_NOVOS = [
+    ['/estudio', 'escolhe o que criar: slides, vídeo, motion, anúncio, abertura'],
+    ['/agentes', 'seus agentes: lista · ligar · desligar · criar · apagar'],
+    ['/piloto', 'piloto automático: on | off [grupo]'],
+    ['/avisos', 'fila de aprovação e avisos · a <n> aprova · r <n> recusa'],
+    ['/buscar', 'procura em projetos, agentes, vídeos e conversas'],
+];
+const COMANDOS = { estudio, projetos, agentes, piloto, avisos, buscar };
+
+/* ── primocode app ──────────────────────────────────────────────────────────── */
+function appInstalado({ env = process.env, plataforma = process.platform, existe = fs.existsSync } = {}) {
+    const alvos = env.PRIMOCODE_APP ? [env.PRIMOCODE_APP] : plataforma === 'darwin'
+        ? ['/Applications/PrimoCode.app', path.join(os.homedir(), 'Applications', 'PrimoCode.app')]
+        : plataforma === 'win32' ? [path.join(env.LOCALAPPDATA || '', 'Programs', 'PrimoCode', 'PrimoCode.exe')]
+            : ['/opt/PrimoCode/primocode', path.join(os.homedir(), '.local', 'bin', 'primocode-app')];
+    return alvos.find((a) => a && existe(a)) || null;
+}
+/** `primocode app`: abre o desktop se instalado; senão diz como. `abrir(caminho)` é injetável (teste não abre nada). */
+function app({ abrir, ...o } = {}) {
+    const a = appInstalado(o);
+    if (!a) return { ok: false, texto: 'O app desktop não está instalado. Baixe em primocode.app (ou rode `primocode server --ws` para usar outra tela). Dentro do repo: `cd app && npm install && npm start`.' };
+    const faz = abrir || ((p) => {
+        const { spawn } = require('child_process');
+        const [bin, args] = process.platform === 'darwin' ? ['open', [p]] : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', p]] : [p, []];
+        spawn(bin, args, { detached: true, stdio: 'ignore' }).unref();
+    });
+    faz(a);
+    return { ok: true, texto: `Abrindo o PrimoCode (${a}).`, caminho: a };
+}
+
+module.exports = { celula, plano, fecho, interrompida, verboDe, contar, zerar, statusLinha, praAprovar, instrucaoDeAgentes, completarArroba, SLASH_NOVOS, COMANDOS, estudio, projetos, agentes, piloto, avisos, buscar, app, appInstalado };

package/lib/config/config.js

@@ -340,17 +340,37 @@ function loadConfig() {
         permissoes: file.permissoes || 'auto',
         // O parceiro do /team (lib/team.js): quem revisa o que o PrimoCode faz. null = sozinho.
         team: file.team || null,
+        // 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,
         _file: file,
     };
 }
 
+/* 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 } = { ...cur, ...partial };
-    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes, team };
+    const { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes, team, piloto, grupo, inicioFeito } = { ...cur, ...partial };
+    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/aprovacao.js

@@ -0,0 +1,114 @@
+// Aprovações e perguntas por evento (docs/estrutura.md, seções 3 e 6.7).
+// O motor PEDE emitindo `approval/requested` ou `question/requested` e espera;
+// quem desenha (a tela do app) responde pelo app-server, e o pedido destrava.
+// Node puro, sem dependência. Sem ninguém respondendo, o turno espera: a tela
+// (ou `cancelar()`, no interromper) decide. O padrão de quem cancela é NÃO.
+'use strict';
+
+const { EVENTOS, novoId } = require('./eventos');
+
+const MAX_PERGUNTAS = 4;
+const MAX_OPCOES = 4;
+const NENHUMA = 'Nenhuma dessas';
+
+/* Uma pergunta limpa: texto, até 4 opções com rótulo e descrição curta. */
+function limparPergunta(p) {
+    const opcoes = (Array.isArray(p && p.opcoes) ? p.opcoes : []).slice(0, MAX_OPCOES).map((o) => (
+        typeof o === 'string' ? { rotulo: o } : { rotulo: String((o && o.rotulo) || ''), descricao: o && o.descricao ? String(o.descricao) : undefined }
+    )).filter((o) => o.rotulo);
+    return { pergunta: String((p && p.pergunta) || '').trim(), opcoes };
+}
+
+function criarPortao({ emitir } = {}) {
+    const pend = new Map();        // id → { tipo, resolver, perguntas? }
+    const saida = typeof emitir === 'function' ? emitir : () => {};
+
+    const status = (estado, rotulo) => saida({ evento: EVENTOS.STATUS, id: novoId(), tipo: 'status', estado, rotulo });
+    const esperando = () => status('esperando', 'esperando você');
+    const voltar = () => { if (!pend.size) status('rodando', 'trabalhando'); };
+
+    function fechar(id, estado, extra) {
+        saida({ evento: EVENTOS.ITEM_TERMINOU, id, tipo: pend.get(id).tipo === 'aprovacao' ? 'aprovacao' : 'pergunta', estado, ...(extra || {}) });
+        pend.delete(id);
+        voltar();
+    }
+
+    /* Mesma assinatura do `autorizar` do runAct: (frase, info) → 'agora' | 'sessao' | 'nao'. */
+    function autorizar(frase, info = {}) {
+        const id = novoId();
+        return new Promise((resolver) => {
+            pend.set(id, { tipo: 'aprovacao', resolver });
+            saida({
+                evento: EVENTOS.APROVACAO, id, tipo: 'aprovacao', estado: 'esperando',
+                texto: String(frase || ''), categoria: info.tipo || 'computador',
+                motivo: info.motivo || undefined, primeira: !!info.primeira,
+            });
+            esperando();
+        });
+    }
+
+    /* `perguntas`: até 4, cada uma com até 4 opções (a tela soma "Nenhuma dessas").
+       Resolve com [{ indice, rotulo, nota, nenhuma }] na mesma ordem; nunca rejeita. */
+    function perguntar({ titulo, perguntas } = {}) {
+        const lista = (Array.isArray(perguntas) ? perguntas : []).slice(0, MAX_PERGUNTAS).map(limparPergunta).filter((p) => p.pergunta);
+        if (!lista.length) return Promise.resolve([]);
+        const id = novoId();
+        return new Promise((resolver) => {
+            pend.set(id, { tipo: 'pergunta', resolver, perguntas: lista });
+            saida({
+                evento: EVENTOS.PERGUNTA, id, tipo: 'pergunta', estado: 'esperando',
+                titulo: titulo || undefined, perguntas: lista, nenhuma: NENHUMA,
+            });
+            esperando();
+        });
+    }
+
+    /* A tela respondeu a uma aprovação: { aceitar, recusar, sempre }. */
+    function responderAprovacao(id, r = {}) {
+        const p = pend.get(id);
+        if (!p || p.tipo !== 'aprovacao') return false;
+        const resposta = r.recusar ? 'nao' : r.sempre ? 'sessao' : r.aceitar ? 'agora' : 'nao';
+        fechar(id, resposta === 'nao' ? 'erro' : 'ok', { resposta });
+        p.resolver(resposta);
+        return true;
+    }
+
+    /* A tela respondeu a uma pergunta: respostas = [{ indice | null, nota }]. */
+    function responderPergunta(id, respostas) {
+        const p = pend.get(id);
+        if (!p || p.tipo !== 'pergunta') return false;
+        const lista = Array.isArray(respostas) ? respostas : [];
+        const saidaR = p.perguntas.map((q, i) => {
+            const r = lista[i] || {};
+            const n = Number.isInteger(r.indice) && r.indice >= 0 && r.indice < q.opcoes.length ? r.indice : null;
+            return { indice: n, rotulo: n === null ? NENHUMA : q.opcoes[n].rotulo, nota: r.nota ? String(r.nota).slice(0, 2000) : undefined, nenhuma: n === null };
+        });
+        fechar(id, 'ok', { respostas: saidaR });
+        p.resolver(saidaR);
+        return true;
+    }
+
+    /* Turno interrompido ou terminado: tudo o que esperava resolve como NÃO / nenhuma. */
+    function cancelar() {
+        for (const [id, p] of [...pend]) {
+            fechar(id, 'interrompido');
+            p.resolver(p.tipo === 'aprovacao' ? 'nao' : p.perguntas.map(() => ({ indice: null, rotulo: NENHUMA, nenhuma: true })));
+        }
+    }
+
+    /* mudar_pasta do agente: uma pergunta de sim/não, com "Nenhuma dessas" valendo não. */
+    async function mudarPasta({ caminho, motivo }) {
+        const r = await perguntar({
+            titulo: 'O Primo quer trabalhar em outra pasta',
+            perguntas: [{ pergunta: `Trabalhar em ${caminho} a partir de agora?${motivo ? ` Motivo: ${motivo}` : ''}`,
+                opcoes: [{ rotulo: 'Sim, trocar', descricao: caminho }, { rotulo: 'Não, ficar onde está' }] }],
+        });
+        if (r[0] && r[0].indice === 0) return { ok: true, caminho };
+        try { require('../tool/tools').liberarLeitura(caminho); } catch { /* sem leitura extra */ }
+        return { ok: false };
+    }
+
+    return { autorizar, perguntar, mudarPasta, responderAprovacao, responderPergunta, cancelar, pendentes: () => [...pend.keys()] };
+}
+
+module.exports = { criarPortao, NENHUMA, MAX_PERGUNTAS, MAX_OPCOES };

package/lib/motor/eventos.js

@@ -0,0 +1,77 @@
+// Eventos do motor (docs/estrutura.md, seção 3). O motor só EMITE; quem
+// desenha (terminal, app desktop, -p) assina. Node puro, sem dependência.
+'use strict';
+
+const EVENTOS = Object.freeze({
+    TURNO_COMECOU: 'turn/started',
+    TURNO_TERMINOU: 'turn/completed',
+    TURNO_INTERROMPIDO: 'turn/interrupted',
+    ITEM_COMECOU: 'item/started',
+    ITEM_DELTA: 'item/delta',
+    ITEM_TERMINOU: 'item/completed',
+    STATUS: 'status/changed',
+    USO: 'usage/updated',
+    APROVACAO: 'approval/requested',
+    PERGUNTA: 'question/requested',
+    AVISO: 'notice/created',
+});
+
+const TIPOS = Object.freeze(Object.values(EVENTOS));
+
+/* Cada "vista" é uma coisa que a tela do terminal sabe desenhar. O evento
+   carrega os campos do contrato (`evento`, `id`, `tipo`, `estado`) e os dados
+   que a tela precisa. Estados: rodando · ok · erro · interrompido. */
+const VISTAS = Object.freeze({
+    'spinner-inicia':  { evento: EVENTOS.STATUS, tipo: 'status', estado: 'rodando' },
+    'spinner-detalhe': { evento: EVENTOS.STATUS, tipo: 'status', estado: 'rodando' },
+    'spinner-para':    { evento: EVENTOS.STATUS, tipo: 'status', estado: 'parado' },
+    'pensamento':      { evento: EVENTOS.ITEM_TERMINOU, tipo: 'raciocinio', estado: 'ok' },
+    'resposta':        { evento: EVENTOS.ITEM_TERMINOU, tipo: 'mensagem', estado: 'ok' },
+    'fluxo-inicia':    { evento: EVENTOS.ITEM_COMECOU, tipo: 'mensagem', estado: 'rodando' },
+    'fluxo-escreve':   { evento: EVENTOS.ITEM_DELTA, tipo: 'mensagem', estado: 'rodando' },
+    'fluxo-fecha':     { evento: EVENTOS.ITEM_TERMINOU, tipo: 'mensagem', estado: 'ok' },
+    'acao':            { evento: EVENTOS.ITEM_COMECOU, tipo: 'chamada', estado: 'rodando' },
+    'resultado':       { evento: EVENTOS.ITEM_TERMINOU, tipo: 'chamada', estado: 'ok' },
+    'resultado-linha': { evento: EVENTOS.ITEM_TERMINOU, tipo: 'chamada', estado: 'ok' },
+    'paralelo':        { evento: EVENTOS.ITEM_COMECOU, tipo: 'agente', estado: 'rodando' },
+    'agente':          { evento: EVENTOS.ITEM_COMECOU, tipo: 'agente', estado: 'rodando' },
+    'agente-voltou':   { evento: EVENTOS.ITEM_TERMINOU, tipo: 'agente', estado: 'ok' },
+    'estudio-progresso': { evento: EVENTOS.ITEM_DELTA, tipo: 'estudio', estado: 'rodando' },
+    'aviso':           { evento: EVENTOS.AVISO, tipo: 'aviso', estado: 'ok' },
+    'problema':        { evento: EVENTOS.AVISO, tipo: 'aviso', estado: 'erro' },
+    'linha':           { evento: EVENTOS.AVISO, tipo: 'aviso', estado: 'ok' },
+});
+
+let SEQ = 0;
+const novoId = () => `i${++SEQ}`;
+
+/* Monta um evento a partir de uma vista. `dados.id` junta eventos do mesmo
+   item (spinner, fluxo); sem ele nasce um id novo. */
+function montar(vista, dados) {
+    const base = VISTAS[vista];
+    if (!base) throw new Error(`vista desconhecida: ${vista}`);
+    return Object.assign({ vista, id: novoId() }, base, dados || {});
+}
+
+/* Emissor mínimo. on('*', fn) escuta tudo. Um assinante que quebra não
+   derruba o turno. emitir(evento) aceita o objeto montado por `montar`. */
+function criarEmissor() {
+    const ouvintes = new Map();
+    const on = (tipo, fn) => {
+        if (!ouvintes.has(tipo)) ouvintes.set(tipo, new Set());
+        ouvintes.get(tipo).add(fn);
+        return () => off(tipo, fn);
+    };
+    const off = (tipo, fn) => { const s = ouvintes.get(tipo); if (s) s.delete(fn); };
+    const emitir = (evento) => {
+        if (!evento || !evento.evento) return;
+        for (const chave of [evento.evento, '*']) {
+            for (const fn of [...(ouvintes.get(chave) || [])]) {
+                try { fn(evento); } catch (e) { if (process.env.PRIMOCODE_DEBUG) console.error('[motor] ouvinte falhou:', e && e.message); }
+            }
+        }
+    };
+    return { on, off, emitir };
+}
+
+module.exports = { EVENTOS, TIPOS, VISTAS, montar, novoId, criarEmissor };

package/lib/motor/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+    ...require('./eventos'),
+    ...require('./turno'),
+    ...require('./aprovacao'),
+    telaTerminal: require('./tela-terminal'),
+};

package/lib/motor/tela-terminal.js

@@ -0,0 +1,64 @@
+// A tela de terminal: assina os eventos do motor e chama exatamente o que
+// `runAct` chamava antes de a tela sair do turno (fala.*, Spinner, logResult).
+// Mesma saída, mesma ordem. O motor não sabe que isto existe.
+'use strict';
+
+const { criarEmissor } = require('./eventos');
+
+/* Uma tela por turno: guarda os spinners e os fluxos abertos, por id. */
+function conectar(emissor) {
+    const em = emissor || criarEmissor();
+    const spinners = new Map();
+    const fluxos = new Map();
+
+    em.on('*', (e) => {
+        // Carregados na hora de usar: act.js carrega este arquivo, e o contrário seria um ciclo.
+        const fala = require('../fala');
+        const { c, Spinner } = require('../tui/ui');
+        const act = require('../session/runner/act');
+        const p = e.profundidade;
+        switch (e.vista) {
+            case 'spinner-inicia':
+                spinners.set(e.id, new Spinner(e.rotulo).start());
+                break;
+            case 'spinner-detalhe': {
+                const sp = spinners.get(e.id);
+                if (sp) sp.detalhe = e.detalhe;
+                break;
+            }
+            case 'spinner-para': {
+                const sp = spinners.get(e.id);
+                if (sp) sp.stop();
+                break;
+            }
+            case 'pensamento': fala.pensamento(e.texto, p); break;
+            case 'resposta': fala.resposta(e.texto); break;
+            case 'fluxo-inicia': {
+                const f = fala.fluxo();
+                fluxos.set(e.id, f);
+                if (e.texto) f.escrever(e.texto);
+                break;
+            }
+            case 'fluxo-escreve': { const f = fluxos.get(e.id); if (f) f.escrever(e.texto); break; }
+            case 'fluxo-fecha': { const f = fluxos.get(e.id); if (f) { f.fechar(); fluxos.delete(e.id); } break; }
+            case 'acao': require('../cli-nova').contar(); fala.acao(e.nome, e.args, p); break;
+            case 'resultado': act.logResult(e.nome, e.resultado, p); break;
+            case 'resultado-linha':
+                console.log(fala.resultado(p) + (e.nivel === 'aviso' ? c.warn(e.texto) : c.muted(e.texto)));
+                break;
+            case 'paralelo': fala.paralelo(e.quantos, p); break;
+            case 'agente': fala.agente(e.rotulo, e.descricao, p); break;
+            case 'agente-voltou': fala.agenteVoltou(e.texto, p); break;
+            case 'aviso': fala.aviso(e.texto); break;
+            case 'problema': fala.problema(e.erro); break;
+            case 'linha': console.log(e.nivel === 'aviso' ? c.warn(e.texto) : e.nivel === 'ok' ? c.ok(e.texto) : e.nivel === 'dim' ? c.dim(e.texto) : e.texto); break;
+            default: break;
+        }
+    });
+    return em;
+}
+
+/* A função `emitir` pronta para o runAct: uma tela de terminal nova. */
+function criar() { return conectar().emitir; }
+
+module.exports = { conectar, criar };

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 };