primocode 11.0.0 → 11.1.0

package/editor/modelo-projeto/build.py

@@ -931,7 +931,8 @@ class Montagem:
         if bw >= W and bh >= H:
             z = zoom
         else:                                      # moldura: rosto com uns 40% da largura da caixa
-            z = max(0.40 * bw / max(1.0, fwp), bw / self.dw, bh / self.dh)
+            # PrimoCode: `zoom` é um múltiplo do enquadramento da moldura (punch-in dentro do quadro; 1.0 = o de sempre)
+            z = max(0.40 * bw / max(1.0, fwp), bw / self.dw, bh / self.dh) * max(1.0, float(zoom))
         # sem mostrar borda: o vídeo (retângulo ox, oy, dw, dh da câmera) cobre a caixa inteira
         x = clamp(bw / 2 - z * cx, bw - z * (self.ox + self.dw), -z * self.ox)
         # foco_y (PrimoCode, camera_viva): sob um título grande no alto, o rosto desce no quadro e abre espaço em cima
@@ -950,7 +951,7 @@ class Montagem:
     def cam_base(self, t, b=None):
         b = b or self.bloco(t)
         if b['cena'] == 'moldura':
-            return self.place(t, self.MOL, b=b)
+            return self.place(t, self.MOL, float(b.get('zoom', 1.0)), b=b)
         if b['cena'] == 'prova':
             z = float(b.get('zoom', 1.0))
             return dict(x=0, y=0, scale=1) if z == 1 else self.place(t, self.FULL, z, b=b)
@@ -986,8 +987,8 @@ class Montagem:
             zs = b.get('zooms') or []
             if not zs:
                 continue
-            if b['cena'] not in ('tela_cheia', 'prova'):
-                raise Erro(f'bloco {b["cena"]} em {b["de"]:.2f} s: "zooms" só vale em tela_cheia e prova')
+            if b['cena'] not in ('tela_cheia', 'prova', 'moldura'):
+                raise Erro(f'bloco {b["cena"]} em {b["de"]:.2f} s: "zooms" só vale em tela_cheia, prova e moldura')
             alvo = 'camera' if not (b['cena'] == 'prova' and b.get('arquivo')) else f'pvw{i}'
             lista = []
             for k, z in enumerate(zs):
@@ -1050,6 +1051,9 @@ class Montagem:
         if z['caixa'] is None:
             s = z['escala'] or 1.3
             if z['alvo'] == 'camera':          # punch-in no rosto
+                bl = self.blocos[z['bloco']]
+                if bl['cena'] == 'moldura':    # dentro do quadro da moldura: múltiplo do enquadramento
+                    return self.place(t, self.MOL, s, b=bl)
                 return self.place(t, self.FULL, s)
             return dict(x=round(W / 2 * (1 - s), 1), y=round(H / 2 * (1 - s), 1), scale=round(s, 4))
         vw, vh, enc = self._midia_px(z['alvo'])
@@ -1147,6 +1151,10 @@ class Montagem:
         sx0, sy0, sx1, sy1 = F['seguro']
         b = self.bloco(t)
         k = b['cena']
+        if k == 'moldura' and b.get('rosto_grande') and onde == 'auto':
+            # PrimoCode: rosto grande (quadro de largura total): a peça fica na faixa de cima, centrada, no topo da zona segura;
+            # pode cobrir cabelo, nunca olhos e boca (que ficam bem abaixo do topo do quadro)
+            return int((sx0 + sx1) / 2 - w / 2), int(sy0)
         if onde == 'baixo_esquerda' or (k == 'moldura' and onde == 'auto'):
             ax0, ay0, ax1, ay1 = F['area_baixo_esq'] if onde == 'baixo_esquerda' else F['area_moldura']
             if h > ay1 - ay0 or w > ax1 - ax0:

package/kits/KITS.md

@@ -1,3 +1,7 @@
+> **Atualização (r2):** o formato abaixo (elementos/, Montagem, receita, exemplos) saiu. Hoje cada estilo é `materiais/<estilo>/`
+> (peças soltas + `pecas.json` + `paleta.json` + `regras.md`; ver `docs/rebuild/motion-materiais-arquitetura.md`) e a pasta
+> `kits/<estilo>/` guarda só `SKILL.md` (nome, família, quando serve) e `capa.jpg` para a galeria.
+
 # KITS.md · o formato de um kit de estilo de motion
 
 Um kit **não é template**. É uma pasta que a IA carrega como uma skill: dentro tem a skill (como o estilo

package/lib/agentes/index.js

@@ -10,7 +10,12 @@ const path = require('path');
 const RAIZ = path.join(__dirname, '..', '..', 'agentes');
 
 const semAcento = (s) => String(s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
-const palavras = (s) => semAcento(s).split(/[^a-z0-9+#.]+/).filter((w) => w.length > 1);
+const PARADAS = new Set(('de do da dos das no na nos nas em um uma uns umas o a os as e ou que com por para pra ao aos se meu minha meus minhas seu sua '
+    + 'esse essa isso este esta isto ele ela eu voce nao sim mais muito tem tudo toda todo quando como onde preciso quero faz fazer fazendo deixa '
+    + 'sobre antes depois ate sem the and for to of in on is it my').split(' '));
+// singulariza de leve (plural -s/-es) para "testes" casar com "teste" e "logs" com "log".
+const raiz = (w) => (w.length > 4 && w.endsWith('es') ? w.slice(0, -2) : w.length > 3 && w.endsWith('s') ? w.slice(0, -1) : w);
+const palavras = (s) => semAcento(s).split(/[^a-z0-9+#.]+/).filter((w) => w.length > 1 && !PARADAS.has(w)).map(raiz);
 
 function frontmatter(texto) {
     const m = String(texto).match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
@@ -62,7 +67,8 @@ function porId(id) {
 }
 
 /** Os N agentes que melhor casam com a consulta (pontos por palavra em palavras > nome/id > quando_usar > area). */
-function buscar(consulta, n = 5) {
+function buscar(consulta, n = 5) { return buscarComPontos(consulta, n).map((x) => x.a); }
+function buscarComPontos(consulta, n = 5) {
     const q = [...new Set(palavras(consulta))];
     const lista = [];
     for (const a of carregar().values()) {
@@ -80,7 +86,7 @@ function buscar(consulta, n = 5) {
         if (pts > 0) lista.push({ a, pts });
     }
     lista.sort((x, y) => y.pts - x.pts || x.a.id.localeCompare(y.a.id));
-    return lista.slice(0, n).map((x) => x.a);
+    return lista.slice(0, n);
 }
 
 function linha(a) { return `${a.id} — ${a.nome} (${a.area}): ${a.quando_usar}`; }
@@ -125,6 +131,29 @@ function ferramentaCapacidade({ consulta, grupo }) {
 }
 
 // ── delegação ───────────────────────────────────────────────────────────
+/**
+ * O roteador de verdade: o que o modelo pediu (`especialista`) passa pela conferência do catálogo.
+ * Modelo pequeno chuta o nome mais famoso (frontend, backend, devops) mesmo havendo um agente mais exato.
+ * - o pedido está entre os 3 melhores da busca pela tarefa: vale o pedido;
+ * - senão, o melhor da busca (se tiver pontos suficientes) entra na frente e o pedido fica de segundo olhar;
+ * - sem pedido: só usa a busca quando ela é confiante (>= 6 pontos).
+ */
+const PONTOS_MINIMOS = 6;
+const FOLGA = 3;   // quanto o melhor da busca precisa estar na frente do pedido para trocá-lo
+function refinar(pedido, tarefa) {
+    const pedidos = resolver(pedido);
+    const top = buscarComPontos(tarefa, 3);
+    const t = top[0];
+    // confiante: 6+ pontos, ou 3+ com folga sobre o segundo (um único termo exato basta se ninguém mais compete)
+    const melhor = t && (t.pts >= PONTOS_MINIMOS || (t.pts >= 3 && (!top[1] || t.pts - top[1].pts >= FOLGA))) ? t : null;
+    if (!melhor) return pedidos;
+    if (!pedidos.length) return [melhor.a];
+    if (pedidos[0].id === melhor.a.id) return pedidos;
+    const p = top.find((x) => x.a.id === pedidos[0].id);
+    if (p && melhor.pts - p.pts < FOLGA) return pedidos;   // o pedido do modelo é quase tão bom quanto o melhor: respeita
+    return [melhor.a, ...pedidos].slice(0, 3);
+}
+
 /** "react" ou "react,seguranca": até 3 olhares na mesma tarefa. Devolve [] se nenhum id existe. */
 function resolver(nomes) {
     const ids = String(nomes || '').split(/[,+;]/).map((s) => s.trim()).filter(Boolean).slice(0, 3);
@@ -141,6 +170,20 @@ function rotulo(agentes) { return agentes.length ? `Agente·${agentes.map((a) =>
 /** O que o Mastermind faz com o que voltou de N especialistas (vai no resultado do lote). */
 const REVISAO_DO_LOTE = '[mastermind] Entregas acima: confira cada "como provar", cruze os contratos entre partes (nomes, rotas, formatos) e mande de volta só o que falhou.';
 
+/** modelo_sugerido do agente (sonnet = trabalho comum, opus = decisão difícil) -> apelido do servidor (main/top). */
+const APELIDO = { sonnet: 'main', opus: 'top', haiku: 'fast' };
+/**
+ * O modelo do subagente. Só mexe quando o placar NÃO tem dado do tipo da tarefa (`placarTemDados` falso)
+ * e o usuário não fixou um modelo (/model id com "/" ou ":"). Vários olhares: vale o mais forte.
+ */
+function modeloPara(agentes, atual, { placarTemDados = false } = {}) {
+    if (placarTemDados || /[\/:]/.test(String(atual || ''))) return atual;
+    const ordem = ['fast', 'main', 'top'];
+    let melhor = -1;
+    for (const a of agentes || []) melhor = Math.max(melhor, ordem.indexOf(APELIDO[String(a.modelo_sugerido || '').toLowerCase()]));
+    return melhor < 0 ? atual : ordem[melhor];
+}
+
 function nucleo() { return require('./nucleo.js').NUCLEO; }
 
-module.exports = { carregar, buscar, porId, briefing, ferramentaBuscar, ferramentaCapacidade, capacidades, gruposDeCapacidades, resolver, montarTarefa, rotulo, nucleo, REVISAO_DO_LOTE, frontmatter, RAIZ };
+module.exports = { carregar, buscar, buscarComPontos, refinar, porId, briefing, ferramentaBuscar, ferramentaCapacidade, capacidades, gruposDeCapacidades, resolver, modeloPara, montarTarefa, rotulo, nucleo, REVISAO_DO_LOTE, frontmatter, RAIZ };

package/lib/agentes/nucleo.js

@@ -14,5 +14,5 @@ Pense como um engenheiro sênior, mesmo sendo um modelo pequeno:
 Parte que pede ofício (linguagem, framework, segurança, design, banco...) ou 2+ partes independentes: agentes_buscar("o que preciso") acha o especialista; spawn_agent especialista="id" (ou "id1,id2" para dois olhares). Vários spawn_agent na mesma resposta rodam em paralelo. O prompt é completo: o subagente não vê esta conversa. Quando voltarem, VOCÊ revisa: confira o "como provar" de cada um, cruze contratos entre as partes, devolva só o que falhou. Edição pequena de um arquivo: faça você.
 
 [geral]
-Você é o agente que faz de tudo: código, pesquisa, texto, shell, git, depuração, dados, arquivos. Há um catálogo de receitas (capacidade_buscar("tarefa"), sem argumento lista os grupos): git, shell, depuração, código, pesquisa, escrita, dados, arquivos, web/API, segurança. Antes de improvisar tarefa conhecida (rebase, bisect, regex, curl com auth, migração), busque a receita: ela traz o passo e a prova. Segredo nunca vai no chat nem no commit. Ação destrutiva ou irreversível: diga o que vai acontecer e peça o sim.`;
+Você é o agente que faz de tudo: código, pesquisa, texto, shell, git, depuração, dados, arquivos. Há um catálogo de receitas (capacidade_buscar("tarefa"), sem argumento lista os grupos): git, shell, depuração, código, pesquisa, escrita, dados, arquivos, web, segurança, frontend, backend, banco, devops, testes, mobile, ia-llm, design, video-motion, marketing, produto-negocio, windows-linux (1000+ receitas). Antes de improvisar tarefa conhecida (rebase, bisect, regex, curl com auth, migração), busque a receita: ela traz o passo e a prova. Segredo nunca vai no chat nem no commit. Ação destrutiva ou irreversível: diga o que vai acontecer e peça o sim.`;
 module.exports = { NUCLEO };

package/lib/agents-md.js

@@ -4,7 +4,7 @@
  *   "Eu preciso de um AGENTS.md com a memória da conversa em cada pasta."
  *   (11/10/2026)
  *
- * O resumo da conversa (lib/memoria-conversa.js) já existia, mas vivia só na
+ * O resumo da conversa (lib/session/memoria-conversa.js) já existia, mas vivia só na
  * memória do processo: fechar o terminal apagava o "de onde parei". Agora,
  * a cada resposta, ele é escrito no AGENTS.md da pasta em que se está — e a
  * próxima sessão aberta ali lê e continua.

package/lib/app-chat.js

@@ -1,7 +1,7 @@
 'use strict';
 // `primocode conversas --json` e `primocode conversa <id> --json`: a ponte do app (docs/app-chat.md).
 const nuvem = require('./nuvem');
-const conta = require('./conta');
+const conta = require('./config/conta');
 
 const PAPEIS = { user: 'voce', assistant: 'primo' };
 

package/lib/backup-banco.js

@@ -8,7 +8,7 @@
  *   desde(projectDir, iso)         → os pendentes feitos a partir de `iso` (os do pedido que o /undo volta)
  *   restaurar(projectDir, backup)  → [{ arquivo, acao }]            (copia de volta e marca como restaurado)
  *
- * O portão (lib/perigo.js) pergunta antes de DROP, TRUNCATE, DELETE sem WHERE e afins, e o checkpoint do /undo só vê a
+ * O portão (lib/permission/perigo.js) pergunta antes de DROP, TRUNCATE, DELETE sem WHERE e afins, e o checkpoint do /undo só vê a
  * pasta: um banco que o .gitignore esconde não voltava. Aqui, quando a pessoa deixa o comando rodar, o arquivo de
  * banco vai pra uma pasta de cópias ANTES, e o /undo devolve. Sem comando novo: quem nunca programou não precisa saber.
  * Só SQLite (arquivo na pasta): Postgres e Supabase moram fora do computador e a cópia não alcança.

package/lib/browser.js

@@ -14,7 +14,7 @@
 
 'use strict';
 
-const snapshot = require('./snapshot.js');
+const snapshot = require('./session/snapshot.js');
 const fs = require('fs');
 const os = require('os');
 const net = require('net');
@@ -496,6 +496,10 @@ async function connect(url) {
     currentSession = new CDPSession();
     currentSession.targetId = target.id;
     await comTeto(currentSession.attach(target.webSocketDebuggerUrl), 12000, 'o canal de controle do navegador');
+    // alert()/confirm() aberto trava a aba inteira (Page.enable e Runtime.evaluate não respondem): fecha o diálogo.
+    const fechaDialogo = () => currentSession.send('Page.handleJavaScriptDialog', { accept: true }, 2000).catch(() => {});
+    currentSession.onEvent = (m) => { if (m === 'Page.javascriptDialogOpening') fechaDialogo(); };
+    await fechaDialogo();
     await currentSession.send('Page.enable');
     await currentSession.send('DOM.enable');
     await currentSession.send('Runtime.enable');
@@ -743,7 +747,7 @@ async function candidatosNaPagina() {
     try { return JSON.parse(await evaluate(js)) || []; } catch { return []; }
 }
 
-/* O retrato da página com as refs (lib/snapshot.js), já em texto. */
+/* O retrato da página com as refs (lib/session/snapshot.js), já em texto. */
 async function retrato(max = 80) {
     try {
         const r = await evaluate(snapshot.scriptDoRetrato(max));
@@ -932,7 +936,7 @@ function lerPortaDoPerfil(perfil) {
 }
 
 /* Quem está subindo o revisor AGORA. O agente liga o navegador escondido
-   adiantado, quando escreve a primeira página (lib/act.js), e a conferência
+   adiantado, quando escreve a primeira página (lib/session/runner/act.js), e a conferência
    do "pronto" chama isto de novo — às vezes com o primeiro ainda subindo.
    Sem esta promessa em comum, a segunda chamada via PORTA_REVISOR zerada e
    lançava um SEGUNDO Chrome, que ficava órfão. */

package/lib/cli/boas-vindas.js

@@ -0,0 +1,153 @@
+/**
+ * boas-vindas.js — a abertura do PrimoCode, na primeira vez e em toda vez.
+ *
+ * Duas coisas acontecem aqui, nesta ordem: a pessoa entra na conta do
+ * PrimoCode, e o plano dela é conferido. Acabou. Não há terceira pergunta.
+ *
+ * ── POR QUE NÃO SE ESCOLHE MAIS A IA ─────────────────────────────────────
+ * Existiam duas telas depois do login: "Com qual IA você quer trabalhar?" e
+ * "Qual conta?" (Claude ou GPT), que ligavam o `/claude` ou o `/gpt` e faziam
+ * o PrimoCode rodar em cima da assinatura da própria pessoa.
+ *
+ * Isso pedia que alguém que acabou de instalar um produto pago já tivesse
+ * OUTRO produto pago instalado e logado — e a resposta certa para quase todo
+ * mundo era a primeira opção. Uma pergunta cuja resposta certa é sempre a
+ * mesma não é escolha, é obstáculo.
+ *
+ * A API vem configurada no produto. Entrou na conta, pode pedir a primeira
+ * coisa.
+ *
+ * Desde 12/10/2026 a conta é do próprio PrimoCode (Firebase, sem o Conecta):
+ * o /login abre o navegador, onde se cria a conta, entra ou redefine a senha,
+ * e `/login senha` faz pelo terminal (ver lib/config/conta.js).
+ *
+ * ── O BLOQUEIO É DE CORTESIA ─────────────────────────────────────────────
+ * Este arquivo vai publicado no npm com o código à vista: um `if (pro)` aqui
+ * é uma linha que qualquer um apaga. Quem segura de verdade é o
+ * primocode-server, que é quem tem a chave do provedor. O que se faz aqui é
+ * dizer o que houve e como resolver.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MARCA = () => path.join(os.homedir(), '.primocode', 'ja-abriu.json');
+
+/** Já passou pela abertura alguma vez? A marca não guarda login nenhum. */
+function jaEscolheu() {
+    try { return fs.existsSync(MARCA()); } catch { return false; }
+}
+
+function marcar(dados = {}) {
+    try {
+        const caminho = MARCA();
+        fs.mkdirSync(path.dirname(caminho), { recursive: true });
+        fs.writeFileSync(caminho, JSON.stringify({ em: new Date().toISOString(), ...dados }, null, 2), 'utf8');
+        return true;
+    } catch { return false; }
+}
+
+function esquecer() {
+    try { fs.rmSync(MARCA(), { force: true }); return true; } catch { return false; }
+}
+
+// ── a abertura ───────────────────────────────────────────────────────────
+
+/**
+ * @param {object} op
+ * @param {(q:string)=>Promise<string>} op.perguntar
+ * @param {(s:string)=>void} op.mostrar
+ * @param {object} op.cores
+ * @param {boolean} op.interativo      false = pipe/CI: não pergunta nada
+ * @param {()=>any} op.conectado       a credencial local, ou null
+ * @param {()=>Promise<any>} op.conectar   roda o login (abre o navegador)
+ * @param {()=>Promise<any>} op.sessao     confirma o plano no documento da conta
+ */
+async function rodar({ perguntar, mostrar, cores: c, interativo = true,
+    conectado, conectar, sessao } = {}) {
+
+    /* Sem terminal de verdade (pipe, script, CI) não se pergunta nada — uma
+       pergunta onde ninguém pode responder trava o processo para sempre, e
+       trava calado. Também não se BLOQUEIA: quem chamou não pode fazer login,
+       e barrar aqui transformaria um script quebrado num script mudo. Quem
+       segura de verdade é o servidor. */
+    if (!interativo) return { liberado: true, motivo: 'sem-terminal', perguntou: false };
+
+    // ── 1. conectar ──────────────────────────────────────────────────────
+    let credencial = conectado ? conectado() : null;
+    if (!credencial) {
+        mostrar('');
+        mostrar(c.bold(c.brand('  Bem-vindo ao PrimoCode.')));
+        mostrar(c.muted('  Primeiro, crie sua conta ou entre nela: vou abrir o navegador.'));
+        mostrar('');
+        const r = await conectar();
+        if (!r || r.ok === false) {
+            mostrar('');
+            mostrar(c.err('  Não deu para conectar' + (r && r.error ? `: ${r.error}` : '.')));
+            mostrar(c.muted('  Tente de novo com ') + c.brand('/login') + c.muted('.'));
+            return { liberado: false, motivo: 'sem-login' };
+        }
+        credencial = conectado ? conectado() : { plano: r.plano };
+    }
+
+    // ── 2. o plano ───────────────────────────────────────────────────────
+    const s = await sessao();
+    if (s && s.offline) {
+        /* Sem rede não se decide. Bloquear alguém porque o wi-fi tropeçou
+           seria transformar um problema de rede num "você não tem acesso" —
+           e a pessoa iria conferir a assinatura, que está em dia. Vale o
+           último plano conhecido; quem confere de verdade é o servidor, na
+           primeira chamada que sair daqui. */
+        mostrar(c.muted('  Sem rede para confirmar o plano — seguindo com o último conhecido.'));
+    } else if (!s || !s.ok) {
+        mostrar('');
+        mostrar(c.err('  Não consegui confirmar sua conta' + (s && s.error ? `: ${s.error}` : '.')));
+        mostrar(c.muted('  Entre de novo com ') + c.brand('/login') + c.muted('.'));
+        return { liberado: false, motivo: 'sessao-invalida' };
+    }
+
+    const plano = (s && s.ok ? s.plano : credencial && credencial.plano) || 'free';
+    const pro = s && s.ok ? !!s.pro : !!(credencial && credencial.pro);
+    if (!pro) {
+        mostrar('');
+        mostrar(c.err('  Sua conta ainda não tem um plano.'));
+        mostrar(c.muted('  O PrimoCode é por assinatura, a partir de ') + c.brand('R$ 69,90/mês') + c.muted('.'));
+        mostrar('');
+        mostrar(c.dim('  Veja os planos e assine: ') + c.brand('/account plans'));
+        mostrar(c.dim('  Já assinou? ') + c.brand('/account')
+            + c.dim(' atualiza o plano nesta máquina.'));
+        mostrar('');
+        return { liberado: false, motivo: 'sem-plano', plano };
+    }
+
+    /* Nada de "Conta liberada." na abertura.
+       Estar logado é o estado NORMAL do produto — anunciar isso toda vez é
+       ruído, e ruído no primeiro instante empurra para baixo o que importa,
+       que é a caixa de digitar. O selo do plano continua existindo onde quem
+       procura vai olhar (/account, /doctor status); a abertura só diz alguma coisa
+       quando há algo a resolver. */
+
+    /* Não há etapa 3. O que vinha aqui era a escolha do provedor de IA, e
+       ela morreu junto com o `/claude` e o `/gpt`: a API já vem com o
+       produto. A marca continua sendo gravada porque é ela que distingue a
+       primeira abertura das outras — quem já entrou não precisa ler o texto
+       de boas-vindas de novo. */
+    const primeira = !jaEscolheu();
+    if (primeira) marcar({ plano });
+
+    /* Na primeira vez a frase serve: a pessoa acabou de instalar e não sabe
+       que já pode pedir. Da segunda em diante ela é só mais uma linha entre
+       a pessoa e o cursor. */
+    if (primeira) {
+        mostrar('');
+        mostrar(c.muted('  Tudo pronto. Pode pedir qualquer coisa, escrevendo normal, como numa conversa.'));
+        mostrar(c.muted('  Nunca programou? Digite ') + c.brand('/new') + c.muted(' e crie seu primeiro app com 3 perguntas.'));
+    }
+    mostrar('');
+    return { liberado: true, plano, primeira, perguntou: false };
+}
+
+module.exports = { rodar, jaEscolheu, marcar, esquecer, MARCA };

package/lib/cli/comando-api.js

@@ -0,0 +1,85 @@
+'use strict';
+/**
+ * comando-api.js — o /api: a chave da própria pessoa (extraído de lib/cli/sessao.js).
+ * Recebe do laço da sessão o que ele tem de vivo: a caixa (`rl`, função porque é reatribuída), `ask` e `askSecret`.
+ */
+const os = require('os');
+const { c } = require('../tui/ui');
+const api = require('../provider/api');
+const provedorLocal = require('../provider/local/provedor');
+
+function criar({ rl, ask, askSecret }) {
+    /* ── /api: a chave da própria pessoa ──────────────────────────────
+     *   "Fica batendo no limite. Coloca um /provider onde você seleciona se é
+     *    Gemini, ChatGPT etc., cola a key e ela roda local." (23/09/2026)
+     * Com provedor, o agente fala direto com a API da pessoa (lib/provider/local/motor.js);
+     * sem, tudo segue pelo servidor como sempre. */
+    async function comandoApi(rest) {
+        const P = provedorLocal.PROVEDORES;
+        const ids = Object.keys(P);
+        const arg = String(rest || '').trim();
+        const atual = provedorLocal.atual();
+
+        if (/^(off|desliga[r]?|servidor|nenhum|sair)$/i.test(arg)) {
+            provedorLocal.desligar();
+            console.log(c.ok('  De volta ao servidor do PrimoCode.') + c.muted('  (a chave foi apagada desta máquina)'));
+            return;
+        }
+        const trocaModelo = arg.match(/^(modelo|model)\s+(\S+)$/i);
+        if (trocaModelo) {
+            if (!atual) { console.log(c.warn('  Nenhum provedor configurado. Rode /api primeiro.')); return; }
+            provedorLocal.trocarModelo(trocaModelo[2]);
+            console.log(c.ok(`  ${atual.nome} · modelo ${trocaModelo[2]}`));
+            return;
+        }
+
+        const apelido = { claude: 'claude-code', gpt: 'chatgpt', openai: 'chatgpt' }[arg.toLowerCase()];
+        let id = apelido || ids.find((k) => k === arg.toLowerCase() || P[k].nome.toLowerCase().startsWith(arg.toLowerCase()) && arg);
+        // A lista numerada, a pergunta e a resposta somem depois da escolha: fica só o resultado (lib/tui/entrada.js, marcar).
+        let marca = null;
+        const tirarLista = () => { if (marca && rl() && rl().voltarPara) rl().voltarPara(marca); marca = null; };
+        if (!id) {
+            if (rl() && rl().marcar) marca = rl().marcar();
+            console.log('');
+            console.log('  ' + c.bold('Com qual IA você quer rodar?') + c.muted('  a sua chave ou a sua assinatura, sem o limite do servidor'));
+            if (atual) console.log('  ' + c.muted('agora: ') + c.white(atual.cli ? atual.nome : `${atual.nome} · ${atual.modelo} · chave ${provedorLocal.mascarar(atual.chave)}`));
+            ids.forEach((k, i) => console.log(`  ${c.brand(String(i + 1))}  ${c.white(P[k].nome.padEnd(24))}${c.dim(P[k].dica)}`));
+            console.log(`  ${c.brand('0')}  ${c.white('Servidor do PrimoCode'.padEnd(24))}${c.dim('sem chave, com o limite do plano')}`);
+            const escolha = String(await ask(`  ${c.brand('?')} Número: `)).trim();
+            if (escolha === '0') { tirarLista(); return comandoApi('off'); }
+            id = ids[Number(escolha) - 1];
+            if (!id) { tirarLista(); console.log(c.muted('  Nada mudou.')); return; }
+        }
+
+        const p = P[id];
+        // Claude Code e Codex não pedem chave: basta a ferramenta estar instalada
+        // e logada. Quem pensa é ela; quem executa é o PrimoCode.
+        if (p.cli) {
+            if (!require('../provider/local/motor-cli').instalado(id)) {
+                tirarLista();
+                console.log(c.warn(`  O ${p.nome} não está instalado nesta máquina.`) + c.muted(`  Veja ${p.onde}`));
+                return;
+            }
+            const salvo = provedorLocal.salvar({ provedor: id, modelo: p.modelos[0] });
+            tirarLista();
+            console.log(c.ok(`  Pronto: ${salvo.nome}`) + c.muted('  · usa a sua assinatura, sem chave'));
+            console.log(c.dim(`  O ${p.nome} decide, o PrimoCode executa. /api off volta ao servidor`));
+            return;
+        }
+        console.log(c.muted(`  Pegue a chave em `) + c.white(p.onde));
+        const chave = String(await askSecret(`  ${c.brand('?')} Cole a chave do ${p.nome} (não aparece na tela): `)).trim();
+        if (!chave) { tirarLista(); console.log(c.muted('  Nada mudou.')); return; }
+        const sp = new Spinner('conferindo a chave').start();
+        const r = await provedorLocal.conferir(id, chave);
+        sp.stop();
+        if (!r.ok) { tirarLista(); console.log(c.warn(`  ${r.error}`)); return; }
+        const salvo = provedorLocal.salvar({ provedor: id, chave, modelo: r.modelo });
+        tirarLista();
+        console.log(c.ok(`  Pronto: ${salvo.nome} · ${salvo.modelo}`) + c.muted(`  · chave ${provedorLocal.mascarar(chave)}`));
+        console.log(c.dim('  Agora os pedidos vão direto daqui, com a sua cota. /api modelo <nome> troca o modelo · /api off volta ao servidor'));
+    }
+
+    return comandoApi;
+}
+
+module.exports = { criar };