primocode 10.17.0 → 10.19.0

package/lib/comandos-extra.js

@@ -228,17 +228,36 @@ const UM_GB = 1024 ** 3;
  *
  * Tudo injetável (`dep`), para o teste passar os casos sem rede nem Chrome.
  */
+/* O servidor atrás da CLI foi o que travou as tarefas em segundo plano em 22/10: a CLI 10.18 mandava as
+   ferramentas novas, e o servidor 10.17.1 nem sabia delas. O /health traz `primocode` (a versão que o
+   servidor acompanha) desde a 10.18; sem o campo, ele é mais velho que isso. Compara major.minor. Pura. */
+function servidorAtrasado(h, local) {
+    const mm = (v) => { const m = String(v || '').match(/^(\d+)\.(\d+)/); return m ? [Number(m[1]), Number(m[2])] : null; };
+    const l = mm(local);
+    if (!h || !l) return null;
+    const conserto = 'quem cuida do servidor publica a versão nova (railway up); até lá, o que é novo nesta versão pode não funcionar';
+    const s = mm(h.primocode);
+    if (!s) return { detalhe: `o servidor é anterior à 10.18 e esta CLI é a ${local}`, conserto };
+    if (s[0] < l[0] || (s[0] === l[0] && s[1] < l[1])) return { detalhe: `o servidor acompanha a ${h.primocode} e esta CLI é a ${local}`, conserto };
+    return null;
+}
+
 async function diagnosticar(dep = {}) {
     const d = {
         versaoNode: process.version,
         minimaNode: '18.17.0',
         plataforma: process.platform,
         saude: null,                 // async () => objeto do /health
+        versaoLocal: (() => { try { return require('../package.json').version; } catch { return null; } })(),
         prazoServidor: 15000,
         provedor: () => null,        // provedor do /api, ou null
         conferirChave: null,         // async (id, chave) => { ok, error }
         cliInstalado: () => false,   // (id) => bool
         acharChrome: () => null,
+        // o olho do vídeo pronto e o texto do gosto (lib/estudio/visao.js); null = não se aplica (fora do Mac)
+        visao: () => { try { const V = require('./estudio/visao.js'); return process.platform === 'darwin' ? V.disponivel() : null; } catch { return false; } },
+        // o Python do editor de vídeo (lib/editor-pro.js): nasce sozinho no 1º uso; aqui só se diz se já existe
+        editorPronto: () => { try { const E = require('./editor-pro.js'); return fs.existsSync(E.venvPython()); } catch { return false; } },
         pythonQuartz: pythonComQuartz,
         raiz: null,
         espaco: espacoLivre,
@@ -257,6 +276,8 @@ async function diagnosticar(dep = {}) {
         try {
             const h = await comPrazo(d.saude(), d.prazoServidor);
             poe(true, 'Servidor', `${h && h.status || 'ok'}${h && h.version ? ' · v' + h.version : ''}`);
+            const atraso = servidorAtrasado(h, d.versaoLocal);
+            if (atraso) poe(false, 'Servidor atrás', atraso.detalhe, atraso.conserto);
         } catch (e) {
             poe(false, 'Servidor', e.message, 'confira a internet; se acabou de ligar, ele acorda em até 1 min — rode /doctor de novo');
         }
@@ -283,6 +304,16 @@ async function diagnosticar(dep = {}) {
     poe(!!chrome, 'Navegador', chrome || 'nenhum Chrome/Edge/Brave encontrado',
         'instale o Google Chrome (google.com/chrome), ou aponte PRIMOCODE_CHROME para o seu');
 
+    // O olho do vídeo e o Python do editor: sem eles, a conferência e a medida do motion ficam pela metade, em silêncio
+    let olho = null;
+    try { olho = d.visao(); } catch { olho = false; }
+    if (olho === null) poe(null, 'Olho do vídeo', 'só no macOS: a conferência visual e o texto do gosto ficam de fora');
+    else poe(!!olho, 'Olho do vídeo', olho ? 'Vision do macOS' : 'sem o Vision do macOS',
+        'instale as ferramentas de linha de comando: xcode-select --install (sem elas, o vídeo pronto não é conferido por texto e rosto)');
+    let editor = false;
+    try { editor = d.editorPronto(); } catch { editor = false; }
+    poe(editor ? true : null, 'Editor de vídeo', editor ? 'Python do editor pronto' : 'ainda não instalado: nasce sozinho no 1º vídeo editado (uns minutos)');
+
     // Cursor (Python + PyObjC) — só existe no macOS
     if (d.plataforma !== 'darwin') {
         poe(null, 'Cursor do Primo', 'só no macOS');
@@ -320,7 +351,7 @@ async function diagnosticar(dep = {}) {
    plano — todo mundo que conversa com o modelo.
 
    Token exato só quando o provedor manda `usage`. Sem isso, a conta é a de
-   bolso: 4 caracteres ≈ 1 token. O /custo diz qual das duas está mostrando. */
+   bolso: 4 caracteres ≈ 1 token. O /usage diz qual das duas está mostrando. */
 function novoContador() { return { porProvedor: {}, desde: Date.now() }; }
 
 const tam = (x) => { try { return typeof x === 'string' ? x.length : JSON.stringify(x || '').length; } catch { return 0; } };
@@ -399,6 +430,41 @@ function resumoCusto(cont) {
 
 function fmtNumero(n) { return Number(n || 0).toLocaleString('pt-BR'); }
 
+/* O /custo pra quem não sabe o que é token: em páginas (≈ 650 tokens numa
+   página de livro em português) e em quem paga. Pelo servidor, o plano cobre;
+   pela chave ou assinatura da pessoa (/api), quem cobra é o provedor dela. */
+const TOKENS_POR_PAGINA = 650;
+function paginas(tokens) {
+    const p = tokens / TOKENS_POR_PAGINA;
+    if (p < 1) return 'menos de 1 página';
+    const n = p < 10 ? Math.round(p) : Math.round(p / 5) * 5;
+    return `~${fmtNumero(n)} ${n === 1 ? 'página' : 'páginas'}`;
+}
+function resumoSimples({ linhas, total }) {
+    if (!linhas.length) return null;
+    const soServidor = linhas.every((l) => l.provedor === 'Servidor PrimoCode');
+    return {
+        frase: `${total.pedidos} ${total.pedidos === 1 ? 'pedido' : 'pedidos'} à IA · ela leu ${paginas(total.enviados)} e escreveu ${paginas(total.recebidos)}`,
+        quemPaga: soServidor ? 'Coberto pelo seu plano: nada a mais sai do seu bolso.'
+            : 'Parte foi pela sua chave ou assinatura (/api): esse uso aparece no painel do provedor.',
+    };
+}
+
+/* O custo de UM pedido, no fim dele: a diferença entre o contador antes e depois. A pesquisa de concorrentes
+   (brechas-2 #1): no Replit o preço só se sabe depois, e assusta. Aqui sai sempre, em páginas e em quem paga.
+   `antes` e `depois` são o que o resumoCusto devolve. Puro. */
+function custoDoPedido(antes, depois) {
+    const ant = new Map(((antes && antes.linhas) || []).map((l) => [l.provedor, l]));
+    const linhas = ((depois && depois.linhas) || []).map((l) => {
+        const a = ant.get(l.provedor) || { pedidos: 0, enviados: 0, recebidos: 0 };
+        return { provedor: l.provedor, pedidos: l.pedidos - a.pedidos, enviados: l.enviados - a.enviados, recebidos: l.recebidos - a.recebidos };
+    }).filter((l) => l.pedidos > 0);
+    if (!linhas.length) return null;
+    const total = linhas.reduce((s, l) => ({ pedidos: s.pedidos + l.pedidos, enviados: s.enviados + l.enviados, recebidos: s.recebidos + l.recebidos }), { pedidos: 0, enviados: 0, recebidos: 0 });
+    const r = resumoSimples({ linhas, total });
+    return `Este pedido: ${r.frase}. ${r.quemPaga.replace(/: nada a mais sai do seu bolso\./, ', nada a mais.')}`;
+}
+
 // ── /copiar ──────────────────────────────────────────────────────────────
 
 /* Quem copia em cada sistema. No Linux há dois mundos (Wayland e X11) e três
@@ -475,10 +541,11 @@ const ATALHOS = [
 ];
 
 module.exports = {
+    servidorAtrasado, custoDoPedido,
     fmtTamanho, quandoFoi, medirPasta, listarProjetos,
     nomeDoNovo, pedidoDoNovo,
     portasDoProjeto, sondarPorta, acharAlvoAbrir,
     diagnosticar, versaoMinima, espacoLivre,
-    novoContador, instalarContador, resumoCusto, fmtNumero,
+    novoContador, instalarContador, resumoCusto, resumoSimples, paginas, fmtNumero,
     copiar, copiadores, buscarHistorico, ATALHOS,
 };

package/lib/comecar.js

@@ -0,0 +1,56 @@
+'use strict';
+/* /comecar: o primeiro app de quem nunca programou.
+   Aqui só mora a função pura que junta as três respostas num pedido. Ela
+   descreve o que a pessoa quer e COMO falar com ela, e nunca escolhe
+   tecnologia: quem decide o caminho é a IA (regra da casa). Citar um
+   framework aqui empurraria todo iniciante para o mesmo lugar, quer o pedido
+   combine com ele ou não. */
+
+const ORIENTACAO = 'Quem pediu nunca programou: explique cada passo em linguagem simples, '
+    + 'sem jargão, e no fim diga como abrir e usar.';
+
+function limpar(v) {
+    return typeof v === 'string' ? v.replace(/\s+/g, ' ').trim().replace(/[.,;:\s]+$/, '') : '';
+}
+
+/* Devolve null quando não há o que criar: sem a primeira resposta não existe
+   pedido, e o chamador cancela com uma linha gentil. Campos pulados somem do
+   texto, para não sobrar "pra , que abre". */
+function montarPedidoComecar({ oque, praQuem, onde } = {}) {
+    const o = limpar(oque);
+    if (!o) return null;
+    const partes = [o];
+    const p = limpar(praQuem);
+    if (p) partes.push(/^(pra|para)\s/i.test(p) ? p : `pra ${p}`);
+    const d = limpar(onde);
+    // "tanto faz" não é uma preferência: a IA escolhe onde abrir.
+    if (d && !/^tanto faz$/i.test(d)) partes.push(/^(que|abre)\b/i.test(d) ? d : `que abre ${d}`);
+    return `${partes.join(', ')}. ${ORIENTACAO}`;
+}
+
+/* Pra quem chega sem ideia: o prompt vazio trava mais que pergunta difícil.
+   São pontos de partida pequenos, que funcionam no primeiro pedido — e só
+   dizem O QUE fazer; o como continua sendo da IA. */
+const IDEIAS = [
+    'uma lista de compras que a família toda edita',
+    'um site da minha loja, com o cardápio e o WhatsApp',
+    'um controle de gastos do mês, com gráfico',
+    'um quiz pra eu estudar pra prova',
+    'uma agenda de clientes com horário marcado',
+    'um joguinho simples pra jogar no celular',
+];
+
+/* A resposta à lista: número escolhe a ideia, texto vale como ideia própria,
+   vazio cancela. */
+function escolherIdeia(resposta) {
+    const r = String(resposta || '').trim();
+    if (!r) return null;
+    const n = Number(r);
+    if (Number.isInteger(n)) return IDEIAS[n - 1] || null;
+    return r;
+}
+
+/* O que dizer logo depois do primeiro app: os dois comandos que salvam quem nunca programou. */
+const DEPOIS_DO_PRIMEIRO_APP = 'Pra ver se o app abre sem erro: /check. Mexeu e quebrou? /restore volta pro último ponto que funcionava.';
+
+module.exports = { montarPedidoComecar, IDEIAS, escolherIdeia, DEPOIS_DO_PRIMEIRO_APP };

package/lib/como-rodar.js

@@ -0,0 +1,66 @@
+/**
+ * como-rodar.js — o /como-rodar: o bloco "Como rodar" do PRIMO.md, escrito sem modelo, pra o dia seguinte.
+ *
+ *   passos(projectDir)          → [{ texto, comando? }]            (lê package.json, a página e o Python)
+ *   bloco(passos)               → o markdown do bloco, entre marcas  (puro)
+ *   gravar(projectDir)          → { arquivo, criou, passos }        (troca só o bloco; o resto do PRIMO.md fica)
+ *
+ * Quem volta ao app no dia seguinte não lembra como abrir ("vibe coding for beginners", tomsguide.com [VERIFICAR]). O
+ * PRIMO.md é lido no começo de todo pedido (o /init escreve ele inteiro, com o modelo); aqui só o pedaço de rodar,
+ * que dá pra tirar do disco sem errar. Rodar de novo substitui o bloco entre as marcas, nunca duplica.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const INICIO = '<!-- primocode:como-rodar -->', FIM = '<!-- /primocode:como-rodar -->';
+const lerJson = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; } };
+const TESTE_PADRAO = /no test specified/;
+
+function passos(projectDir) {
+    const out = [];
+    const pkg = lerJson(path.join(projectDir, 'package.json'));
+    if (pkg) {
+        const s = pkg.scripts || {};
+        if (!fs.existsSync(path.join(projectDir, 'node_modules')) && (pkg.dependencies || pkg.devDependencies)) out.push({ texto: 'Instalar as dependências (uma vez só)', comando: 'npm install' });
+        if (s.dev) out.push({ texto: 'Abrir pra mexer (recarrega sozinho)', comando: 'npm run dev' });
+        else if (s.start) out.push({ texto: 'Abrir o app', comando: 'npm start' });
+        if (s.test && !TESTE_PADRAO.test(s.test)) out.push({ texto: 'Conferir se está funcionando', comando: 'npm test' });
+        if (s.build) out.push({ texto: 'Gerar a versão final', comando: 'npm run build' });
+    }
+    if (!out.some((p) => p.comando && /run dev|start/.test(p.comando))) {
+        const pagina = ['index.html', 'public/index.html'].find((f) => fs.existsSync(path.join(projectDir, f)));
+        if (pagina) out.push({ texto: `Abrir ${pagina} no navegador (dois cliques no arquivo), ou /open ${pagina} no PrimoCode` });
+        for (const py of ['main.py', 'app.py']) if (fs.existsSync(path.join(projectDir, py))) out.push({ texto: 'Rodar o programa', comando: `python3 ${py}` });
+    }
+    if (out.length) {
+        out.push({ texto: 'Mostrar no celular de alguém no mesmo Wi-Fi, sem publicar: /show no PrimoCode' });
+        out.push({ texto: 'Ver se ainda funciona depois de mexer: /check; quebrou, /restore' });
+    }
+    return out;
+}
+
+function bloco(lista) {
+    const linhas = [INICIO, '## Como rodar', ''];
+    if (!lista.length) linhas.push('Ainda não deu pra saber como este projeto roda: não tem package.json, index.html nem main.py.');
+    lista.forEach((p, i) => linhas.push(`${i + 1}. ${p.texto}${p.comando ? `: \`${p.comando}\`` : ''}`));
+    linhas.push('', '_Escrito pelo /howto do PrimoCode. Rodar de novo atualiza este bloco._', FIM);
+    return linhas.join('\n');
+}
+
+function gravar(projectDir) {
+    const arquivo = path.join(projectDir, 'PRIMO.md');
+    const lista = passos(projectDir);
+    const novo = bloco(lista);
+    let atual = '';
+    try { atual = fs.readFileSync(arquivo, 'utf8'); } catch { /* nasce agora */ }
+    const i = atual.indexOf(INICIO), f = atual.indexOf(FIM);
+    const texto = i >= 0 && f > i ? atual.slice(0, i) + novo + atual.slice(f + FIM.length)
+        : (atual.trim() ? atual.replace(/\s*$/, '\n\n') : '') + novo + '\n';
+    fs.writeFileSync(arquivo, texto);
+    return { arquivo, criou: !atual, passos: lista };
+}
+
+module.exports = { passos, bloco, gravar, INICIO, FIM };

package/lib/conferir.js

@@ -0,0 +1,117 @@
+/**
+ * conferir.js — o "funcionou / não funcionou" para quem não programa.
+ *
+ * A queixa nº 1 de quem constrói sem saber código é "conserta um, quebra
+ * outro", sem ninguém dizer se o projeto ainda funciona. O `/conferir` acha
+ * sozinho o jeito de testar a pasta (teste, build ou lint), roda e responde
+ * em português simples. Quando passa, o checkpoint marca o ponto como
+ * "funcionava" e o `/voltar` sabe para onde ir.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const tools = require('./tools');
+
+const TIMEOUT = 5 * 60 * 1000;
+/** O `npm init` cria esse script de mentira; rodá-lo sempre "falha" e não diz nada. */
+const TESTE_PADRAO_NPM = /no test specified/i;
+
+function lerJson(arquivo) {
+    try { return JSON.parse(fs.readFileSync(arquivo, 'utf8')); } catch { return null; }
+}
+
+/* Só conta como "tem teste" quando existe arquivo de teste: um pyproject.toml sozinho (todo projeto Python moderno
+   tem) fazia o pytest sair com "no tests ran" e virar "✗ os testes falharam" (achado da revisão de 24/10). */
+const ARQ_TESTE_PY = /^(test_.*|.*_test)\.py$/;
+function temTestePython(projectDir) {
+    const tem = (dir) => { try { return fs.readdirSync(dir).some((f) => ARQ_TESTE_PY.test(f)); } catch { return false; } };
+    return tem(projectDir) || tem(path.join(projectDir, 'tests')) || tem(path.join(projectDir, 'test'));
+}
+
+/** Como testar esta pasta: { comando, rotulo } ou null. Do mais forte (teste)
+    ao mais fraco (lint): um build que passa ainda prova que o projeto monta. */
+/** O gerenciador do projeto: o `packageManager` do package.json, senão o lockfile. `npm test` num projeto pnpm
+    falha por motivo que não é do código (node_modules de outro formato, workspace) e o agente "consertava" o certo. */
+function gerenciador(projectDir, pkg) {
+    const pm = String((pkg && pkg.packageManager) || '').split('@')[0];
+    if (['pnpm', 'yarn', 'bun', 'npm'].includes(pm)) return pm;
+    const tem = (f) => fs.existsSync(path.join(projectDir, f));
+    if (tem('pnpm-lock.yaml')) return 'pnpm';
+    if (tem('yarn.lock')) return 'yarn';
+    if (tem('bun.lock') || tem('bun.lockb')) return 'bun';
+    return 'npm';
+}
+function comandoDo(pm, script) {
+    if (script === 'test') return pm === 'bun' ? 'bun run test' : `${pm} test`;
+    return pm === 'yarn' ? `yarn ${script}` : `${pm} run ${script}`;
+}
+
+function descobrir(projectDir) {
+    const pkg = lerJson(path.join(projectDir, 'package.json'));
+    const scripts = (pkg && pkg.scripts) || {};
+    const pm = pkg ? gerenciador(projectDir, pkg) : 'npm';
+    if (scripts.test && !TESTE_PADRAO_NPM.test(scripts.test)) return { comando: comandoDo(pm, 'test'), rotulo: 'os testes' };
+    if (scripts.build) return { comando: comandoDo(pm, 'build'), rotulo: 'o build' };
+    if (scripts.lint) return { comando: comandoDo(pm, 'lint'), rotulo: 'o lint' };
+    if (temTestePython(projectDir)) return { comando: 'python3 -m pytest -q', rotulo: 'os testes' };
+    if (fs.existsSync(path.join(projectDir, 'Cargo.toml'))) return { comando: 'cargo test', rotulo: 'os testes' };
+    if (fs.existsSync(path.join(projectDir, 'go.mod'))) return { comando: 'go test ./...', rotulo: 'os testes' };
+    return null;
+}
+
+/** Roda o comando na pasta. Mesmo ambiente limpo do run_shell do agente:
+    o que a pessoa vê aqui é o que a IA veria, sem vazar chave para o teste. */
+async function rodar(cmd, projectDir, { timeout = TIMEOUT } = {}) {
+    const env = tools.ambienteLimpo(process.env, tools.permitidasNoShell());
+    // pela mesma cerca do run_shell do agente (lib/sandbox.js): com o /sandbox ligado, o teste também roda dentro dela,
+    // porque o script de teste é código do projeto, que o agente pode ter escrito (achado da revisão de 24/10)
+    const r = await require('./sandbox.js').executar(cmd, { projectDir, timeout, env });
+    // a saída longa guarda o começo, as linhas de falha do meio e o fim (lib/saida.js): o fim sozinho perdia a falha
+    const saida = require('./saida.js').cortar(`${r.stdout || ''}${r.stderr || ''}`.replace(/\s+$/, ''), 3500).split('\n');
+    while (saida.length && !saida[saida.length - 1].trim()) saida.pop();
+    // `estourou`: o prazo matou o comando. Não é "falhou": quem chama não deve julgar o projeto por isso.
+    // O mesmo pro pytest que não achou teste (código 5) ou nem está instalado: não é o projeto que quebrou.
+    const semTeste = /pytest/.test(cmd) && (r.code === 5 || /No module named pytest/.test(`${r.stdout || ''}${r.stderr || ''}`));
+    return { ok: !!r.ok, codigo: r.code, estourou: (!r.ok && !!r.killed) || semTeste, semTeste, saida: saida.join('\n') };
+}
+
+/* Quando o agente roda os testes sozinho, no fim da tarefa (lib/act.js): só se mexeu em arquivo desde a
+   última vez, no máximo 2 vezes por tarefa (entregar, e conferir o conserto), nunca no subagente, e nunca
+   com PRIMOCODE_SEM_TESTE_AUTO=1. Puro. */
+function podeRodarSozinho({ subagent = false, mexeu = false, rodadas = 0, parar = false, modo = 'auto', env = process.env } = {}) {
+    // no "perguntar" a pessoa quer aprovar cada comando, e no "plano" nada roda: rodar sozinho seria passar por cima
+    if (modo === 'perguntar' || modo === 'plano') return false;
+    return !subagent && mexeu && rodadas < 2 && !parar && env.PRIMOCODE_SEM_TESTE_AUTO !== '1';
+}
+const PRAZO_SOZINHO = Number(process.env.PRIMOCODE_PRAZO_TESTE_AUTO) || 2 * 60 * 1000;
+
+const LINHA_DE_ERRO = /error|erro|fail|falh|✗|assert|traceback/i;
+
+/** A resposta para a pessoa. Na falha, só as linhas que explicam (3 a 6): a
+    saída inteira de um build assusta e esconde o motivo. */
+function explicar(r, { rotulo }) {
+    if (r.ok) return { titulo: `Funcionou: ${rotulo} passaram.`, linhas: [] };
+    const todas = String(r.saida || '').split('\n').map((l) => l.trimEnd()).filter((l) => l.trim());
+    let linhas = todas.filter((l) => LINHA_DE_ERRO.test(l)).slice(0, 6);
+    if (linhas.length < 3) {
+        // Achou pouco: a frase do erro mais o que vem logo depois dela (o
+        // trecho do código) explica melhor do que o rabo da saída.
+        const primeira = todas.findIndex((l) => LINHA_DE_ERRO.test(l));
+        linhas = primeira >= 0 ? todas.slice(primeira, primeira + 4) : todas.slice(-6);
+    }
+    return { titulo: `Não funcionou: ${rotulo} falharam.`, linhas };
+}
+
+/* Sem script de teste mas com página (o app que o /comecar faz é index.html): abrir escondido e olhar é o teste
+   que existe (lib/pipeline.js medirNoNavegador, o mesmo olho que o agente usa antes do "pronto"). Puro. */
+function explicarPagina(m) {
+    if (!m || !m.testou) return { ok: false, testou: false, titulo: 'Não consegui abrir a página pra testar.', linhas: m && m.relato ? [String(m.relato).slice(0, 200)] : [] };
+    if (m.limpo) return { ok: true, testou: true, titulo: 'Funcionou: a página abre sem erro.', linhas: [] };
+    const linhas = String(m.relato || '').split('\n').filter((l) => /·|EM BRANCO/.test(l)).map((l) => l.trim()).slice(0, 6);
+    const branco = m.medida && m.medida.vazio;
+    return { ok: false, testou: true, titulo: branco ? 'Não funcionou: a página abre em branco.' : 'Não funcionou: a página abre com erro.', linhas };
+}
+
+module.exports = { descobrir, rodar, explicar, explicarPagina, podeRodarSozinho, PRAZO_SOZINHO };

package/lib/config.js

@@ -338,6 +338,8 @@ function loadConfig() {
         // O /permissoes: quando ele pergunta antes de agir. Dura entre sessões
         // pelo mesmo motivo do modo — quem escolheu "perguntar" quer amanhã também.
         permissoes: file.permissoes || 'auto',
+        // O parceiro do /team (lib/team.js): quem revisa o que o PrimoCode faz. null = sozinho.
+        team: file.team || null,
         rootDir: ROOT_DIR,
         _file: file,
     };
@@ -347,8 +349,8 @@ 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 } = { ...cur, ...partial };
-    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes };
+    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 };
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
     return next;
 }