primocode 11.0.0 → 11.2.0

package/lib/skill/catalogo.js

@@ -0,0 +1,369 @@
+/**
+ * O que o PrimoCode sabe fazer — a lista, em um lugar só.
+ *
+ * Existe porque "o que ele faz" estava espalhado entre o README, o /help, o
+ * prompt do servidor e o switch do `tools.js`, e quatro cópias da mesma verdade
+ * significam que pelo menos uma está mentindo.
+ *
+ * O `test/catalogo.test.js` cruza esta lista com as tools que o `tools.execute`
+ * realmente atende: item aqui que não existe lá derruba o teste, e tool que
+ * existe lá e não está aqui também. A lista não consegue mentir.
+ *
+ * `escreve: true` marca a ferramenta que cria ou muda arquivo. É o que decide
+ * quando nasce uma pasta de projeto — pedir para abrir o Chrome não cria projeto.
+ */
+
+'use strict';
+
+const GRUPOS = [
+    {
+        nome: 'Arquivos',
+        resumo: 'ler, criar e mudar arquivo na pasta de trabalho',
+        itens: [
+            { tool: 'write_file', escreve: true,  faz: 'cria arquivo, ou reescreve inteiro',
+              args: 'path: caminho relativo, ex "src/app.js". content: conteúdo completo do arquivo.' },
+            { tool: 'edit_file',  escreve: true,  faz: 'troca um trecho exato, sem reescrever o resto',
+              args: 'path. old_string: trecho exato a substituir, precisa ser único no arquivo. new_string: texto que entra no lugar. replace_all (opcional, bool, padrão false): troca todas as ocorrências.' },
+            { tool: 'multi_edit', escreve: true,  faz: 'várias trocas no mesmo arquivo, tudo ou nada',
+              args: 'path. edits: lista de {old_string, new_string, replace_all (opcional)}, aplicadas em ordem.' },
+            { tool: 'read_file',  escreve: false, faz: 'lê arquivo, inteiro ou por pedaço',
+              args: 'path. offset (opcional, número): primeira linha a ler. limit (opcional, número): quantas linhas.' },
+            { tool: 'list_dir',   escreve: false, faz: 'mostra a árvore de pastas',
+              args: 'path (opcional, padrão "."). depth (opcional, número, padrão 2).' },
+            { tool: 'glob',       escreve: false, faz: 'acha arquivo pelo nome (**/*.js)',
+              args: 'pattern: padrão de nome, ex "**/*.js" ou "src/**/*.{ts,tsx}". Numa pasta que o usuário citou: padrão absoluto ("/caminho/**/*.js"), sem trocar a de trabalho.' },
+            { tool: 'grep',       escreve: false, faz: 'acha texto dentro dos arquivos',
+              args: 'pattern: expressão regular. glob (opcional): restringe aos arquivos que casam. ignoreCase (opcional, bool). contexto (opcional, número): linhas ao redor do achado. Numa pasta que o usuário citou: glob absoluto ("/caminho/**"), sem trocar a de trabalho.' },
+        ],
+    },
+    {
+        nome: 'Terminal',
+        resumo: 'rodar comando na sua máquina',
+        itens: [
+            { tool: 'run_shell',           escreve: false, faz: 'roda comando e devolve a saída',
+              args: 'command. timeout_ms (opcional, número, padrão 60000). em_segundo_plano (opcional, true): roda solto, devolve um id e avisa quando terminar.' },
+            { tool: 'run_in_new_terminal', escreve: false, faz: 'abre outro terminal quando a PESSOA quer ver o servidor ou o watch rodando',
+              args: 'command. cwd (opcional): pasta onde rodar.' },
+            { tool: 'run_background',      escreve: false, faz: 'se o comando fica de pé (servidor, watch), roda em segundo plano e deixa você ler a saída depois',
+              args: 'command. Devolve um id; confira que subiu com background_output.' },
+            { tool: 'background_output',   escreve: false, faz: 'lê a saída de uma tarefa em segundo plano (só o que é novo desde a última leitura)',
+              args: 'id. desde (opcional, número): o "ate" da leitura anterior.' },
+            { tool: 'stop_background',     escreve: false, faz: 'para uma tarefa em segundo plano',
+              args: 'id.' },
+        ],
+    },
+    {
+        nome: 'Navegador',
+        resumo: 'controla um navegador de verdade (Chrome, Edge, Brave, Arc…) — clica, digita, lê, fotografa',
+        itens: [
+            { tool: 'browser_open',       escreve: false, faz: 'abre uma página ou um arquivo seu',
+              args: 'url: http(s) ou caminho de arquivo do projeto.' },
+            { tool: 'browser_click',      escreve: false, faz: 'clica por texto, por seletor ou por coordenada',
+              args: 'text (opcional): texto visível do elemento. selector (opcional): seletor CSS. x, y (opcional, número): último recurso.' },
+            { tool: 'browser_type',       escreve: false, faz: 'digita num campo',
+              args: 'text. selector (opcional): foca esse campo antes de digitar. clear (opcional, bool, padrão true).' },
+            { tool: 'browser_key',        escreve: false, faz: 'aperta tecla (Enter, Tab, Escape)',
+              args: 'key: nome da tecla (Enter, Tab, Escape, ArrowDown, ArrowUp, ArrowLeft, ArrowRight, Backspace).' },
+            { tool: 'browser_read',       escreve: false, faz: 'lê o texto da página para conferir o resultado',
+              args: 'selector (opcional): lê só esse elemento; sem isso, a página inteira.' },
+            { tool: 'browser_screenshot', escreve: true,  faz: 'tira foto da página',
+              args: 'path (opcional): onde salvar, ex "print.png". Sem path, usa um nome padrão.' },
+            { tool: 'browser_scroll',     escreve: false, faz: 'rola a página',
+              args: 'dy (opcional, número, padrão 600).' },
+            { tool: 'browser_wait',       escreve: false, faz: 'espera um elemento aparecer',
+              args: 'selector: seletor CSS a esperar. timeout_ms (opcional, número, padrão 15000).' },
+            { tool: 'browser_eval',       escreve: false, faz: 'roda JavaScript na página',
+              args: 'js: trecho de JavaScript a rodar na página, devolve o resultado.' },
+            { tool: 'open_in_browser',    escreve: false, faz: 'abre no seu navegador normal, sem controlar',
+              args: 'target: arquivo do projeto ou URL.' },
+        ],
+    },
+    {
+        nome: 'Estúdio',
+        resumo: 'vídeo, motion, slides e arte — a IA faz, e no fim abre o resultado pronto',
+        itens: [
+            { tool: 'estudio_criar', escreve: true, faz: 'a porta simples: cria slides, vídeo, motion, anúncio ou abertura do pedido ao arquivo, e abre o resultado',
+              args: 'tipo (slides|video|motion|anuncio|abertura). briefing (uma frase). duracao (s, opcional). formato (9:16|16:9|1:1, opcional). Para controle fino use as outras estudio_*.' },
+            { tool: 'estudio_projeto', escreve: true, faz: 'abre, acha e lista os projetos do estúdio — cada peça é uma pasta que não some',
+              args: 'acao: criar | abrir | procurar | listar | anotar | editar | assinatura. '
+                + 'assinatura: quando o usuário diz o que achou de um vídeo ("adorei a virada", "texto demais"), grave com texto (e o id) — o próximo vídeo parte disso; sem texto, lê as faixas e as notas. '
+                + 'editar: id (sem id, o mais novo) — quando o usuário quer EDITAR um vídeo que o Estúdio fez, '
+                + 'abre o projeto no Remotion Studio (o editor, no navegador) e devolve a pasta. '
+                + 'criar: titulo, pedido, formato (video|slides|arte). '
+                + 'abrir: id — devolve o plano, o CADERNO (o que foi decidido e por quê) e os arquivos. '
+                + 'procurar: texto — acha pelo que o usuário lembra ("aquele do PicPay"), inclusive por detalhe do meio do processo. '
+                + 'SEMPRE procure antes de criar quando o pedido falar de algo que já existe.' },
+
+            { tool: 'estudio_plano', escreve: true, faz: 'escreve ou ajusta o que o vídeo É — cenas, elementos, animação, câmera, áudio',
+              args: 'id. PREFIRA roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, '
+                + 'partes:[{tipo, fala, …}], estrutura} — estrutura é a que VOCÊ escolheu pelo pedido (historia|problema-solucao|lista|pergunta-resposta|dialogo|demonstracao|mito-verdade|dado-surpresa, ou outra com nome); o PrimoCode faz o layout, a voz com entonação, os ícones, a música e os sons. '
+                + 'Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens} passos{titulo,itens} '
+                + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
+                + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). O texto da TELA sai da FALA: o título usa palavras que a fala diz, cedo na frase (a tela entra quando a voz diz; palavra que a voz não diz deixa a tela esperando). '
+                + 'visual:{titulo,texto,paleta} (hibrido, cinema, impacto): fonte e cor do cardápio (estudio_midia acao:fontes); sem visual, o PrimoCode sorteia sem repetir os últimos vídeos. '
+                + 'componente:"componentes/x.jsx" numa parte = a cena que VOCÊ escreveu em React — é o caminho do motion (skill Motion de primeira): uma ideia desenhada por fala; a voz, a trilha, os sons e o fundo seguem do Estúdio; cena que não compila volta em cenasQuebradas. '
+                + 'semNarracao:true no roteiro (ou pedido "sem narração") = vídeo só com motion, trilha e efeitos sonoros: sem estudio_narrar, cada parte dura o seu "duracao" (s) ou o tempo de ler a tela, e um som leve entra em cada corte e entrada. Toda parte aceita sons:[{t, som}] (t na parte; pop, mouse, tique, digital, swoosh, sub, ponto1..ponto5) para o barulhinho cair no quadro em que a coisa acontece. '
+                + 'estilo (deixe VAZIO: o gerativo, com as suas cenas em componente e o estiloVisual que você montou; outro só se a pessoa pedir pelo nome): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega — a COISA que a frase nomeia, 2 a 4 palavras, não a frase inteira; rota:"tipografia" em número/citação, "produto" quando a frase fala do produto; ancora:"palavra" — o clipe troca 0,2 s depois dela) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som — estiloVisual {humor, paleta, display, texto, mono, genero, ambiente, acento, material} é o estilo que VOCÊ monta pelo assunto (cardápio: estudio_midia acao:estilos; vazio, o PrimoCode sorteia); modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — SÓ quando a pessoa pedir; vazio = sem moldura (ela entrega que o vídeo foi gerado); heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone 3D RENDERIZADO da biblioteca ("fluent3d:hot beverage", "fluent3d:money bag"; procure com estudio_midia acao:icones3d — é o que mais parece 3D de verdade), uma animação pronta ("noto:1f525"; acao:animacoes), um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | impacto | cinema | personagem (a ANIMAÇÃO 3D de verdade, o vídeo GRAVADO em 3D no visual de blocos/voxel de render de cinema — é a escolha para animação 3D, personagem, bicho, boneco, avatar, mascote, podcast, entrevista ou alguém FALANDO em 3D; cada parte é UMA fala {falante, texto, emocao?, destaque?, acao?, cenario?}, sem tipo). NADA É FIXO, monte o que a pessoa pediu: cena:"texto livre do lugar" (praia, cidade, floresta, parque, fazenda, neve, deserto, espaço, fundo do mar, escritório, sala, cozinha, escola, palco… + hora: "à noite", "ao pôr do sol") ou cena:{lugar, hora, elementos:["palmeira","barraca","violão",…]} — elemento fora do catálogo vira ícone 3D em blocos; parte.cenario muda o lugar a partir daquela fala. Até 4 falantes; personagens:{"nome":{tipo:pessoa|robo|animal|coisa, especie (animal: cachorro|gato|cavalo|vaca|porco|ovelha|raposa|lobo|urso|panda|coelho|leao|tigre|elefante|girafa|tartaruga|galinha|pato|passaro|papagaio|coruja|pinguim|peixe|tubarao|golfinho|dinossauro|sapo|macaco), icone (coisa: "pizza", "café", "polvo" — qualquer objeto/bicho que fala), pessoa: pele, cabelo:curto|cacheado|longo|topete|coque|careca, corCabelo, roupa, oculos, barba; robo: cor}} — sem tipo, o nome decide (nome de bicho vira bicho, de IA vira o mascote laranja, de objeto vira coisa); figurantes:["cachorro","pessoa"] (quem está na cena sem falar); BICHO NÃO FALA: a fala de um bicho sai da narração e ele fica na cena — só fala se a pessoa pedir ("cachorro falante") ou personagens.x.fala:true; a voz de cada falante sai do GÊNERO do nome (personagens.x.genero:f|m manda), uma voz por personagem do começo ao fim; bigode:true e cabeca:"cubo" (o rosto de pixel antigo) em personagens; sem lugar no pedido, o set é a cobertura à noite (janela da cidade, cartões de interface na frente). acao em cada parte: acenar|apontar|pular|dancar|comemorar|pensar|andar|correr. emocao feliz|serio|surpreso|pensativo|animado|curioso; destaque:"texto curto"; paineis:["título",…] só no set de telas (o padrão quando o pedido não diz lugar); visual:"liso" só se pedirem o boneco liso antigo). '
+                + 'marca e lancamento aceitam visual:orbe|vetor|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
+                + 'voz (thalita|antonio|francisca). DUAS VOZES (o pedido fala em dois narradores, diálogo, conversa, entrevista): roteiro.vozes {"nome":"antonio","outro":"thalita"} e falante:"nome" em cada parte — cada um sai na sua voz. Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
+                + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '
+                + 'motivo (opcional): fica no caderno. voltarPara (opcional): nome de uma versão. '
+                + 'Sem plano nem cenas, LÊ o plano atual. '
+                + 'Cada elemento é {tipo: texto|forma|imagem|video|icone|legenda|componente|kit} com x, y, cor, tamanho e '
+                + '"anima": {propriedade: [{t,v,e}]} — quadros-chave em segundos. A cena tem "camera": {zoom,x,y,rotacao} e '
+                + '"perspectiva" para 3D. Cena.transicao {tipo,duracao}: corte|esmaecer|deslizar|zoom|giro|mascara|morph|chicote|soco|flash|liquido, '
+                + 'e as 3D virar|cubo|profundidade|inclinar (mexem nas duas cenas) — use 3D se o vídeo pede volume (produto, site, tecnologia); em editorial plano, prefira as planas. '
+                + 'NÃO existe layout pronto nem tema — cada propriedade do vídeo é escolha sua, a cada vídeo. '
+                + 'ÁREA SEGURA: nada a menos de 6% da largura e 7% da altura da borda, e 4% do lado curto entre dois elementos no ar juntos — '
+                + 'o render empurra para dentro, encolhe o texto largo e afasta o colado; enfeite de fundo marque decorativo: true.' },
+
+            { tool: 'estudio_midia', escreve: true, faz: 'procura e baixa ícone, imagem, música e efeito sonoro da internet, e lista as fontes',
+              args: 'acao: biblioteca | projetos | projeto | estilos | salvar_estilo | movimentos | cenarios | salvar_cenario | imagem | icones | icones3d | animacoes | som | trilha | efeito | fontes | print | elementos | elemento | recortar. termo. id (para baixar). '
+                + 'projetos termo categoria:narrado|produto|saas|sound|elementos|ae: receitas de projeto completo (ficha, etapas, prompt); projeto nome:"<id>" traz a receita inteira. '
+                + 'movimentos termo:"quique" categoria:entrada|saida|enfase|loop: os 100+ movimentos prontos com nome; no elemento, movimento:"<nome>" (ou {nome, em, duracao}, ou uma lista) vira quadros-chave sozinho. Varie: não use o mesmo em todo elemento. Pode inventar o seu em anima. '
+                + 'estilos: as peças do gerativo (humor, paleta, fontes, trilha, ambiente, acento, material) — dezenas de milhares de combinações, e os estilos que a pessoa salvou. '
+                + 'Monte o do vídeo pelo ASSUNTO em roteiro.estiloVisual; misture um salvo com {base:"<nome>", ...}; crie paleta nova com 5 cores. '
+                + 'No fim, pergunte "posso salvar este estilo pra usar nos próximos vídeos?" e, SÓ com o sim, salvar_estilo com nome, pecas {…} e autorizado:true. '
+                + 'cenarios: os lugares prontos do vídeo 3D e os que a pessoa já salvou. Pode CRIAR um cenário novo na cena (lugar base + ceu, chao, parede, luz, acento, hora, elementos); '
+                + 'no fim do vídeo pergunte "posso salvar este cenário pra usar na próxima vez?" e, SÓ com o sim, salvar_cenario com nome, cenario {…} e autorizado:true. Depois, lugar:"<nome>" traz ele de volta. '
+                + 'biblioteca: o cardápio INTEIRO do que existe (ícone 2D, ícone 3D, animação pronta, efeito sonoro, música, fonte, personagem 3D) — olhe antes de escolher. '
+                + 'icones3d termo:"coffee": os 1.500+ ícones 3D renderizados do Fluent Emoji (MIT); com item:"fluent3d:<nome>" e o id do projeto, baixa e devolve o elemento {tipo:"imagem"} pronto. '
+                + 'animacoes termo:"fire": as 881 animações prontas do Noto (Lottie, vetor; CC BY 4.0, ponha o crédito); com item:"noto:<código>", baixa e devolve o elemento {tipo:"kit", peca:"animacao", src, loop} pronto. '
+                + 'O termo vai em inglês (as palavras comuns em português também casam). Escolha pelo que a fala DIZ: numa conversa sobre café, a xícara; nunca enfeite sem relação. '
+                + 'print: url — tira o print REAL do site e devolve o src e um elemento {tipo:"kit", peca:"printsite"} pronto '
+                + '(o site de verdade numa janela 3D que rola a página; celular: true para a tela do celular; inteira: false só a primeira dobra). '
+                + 'Use SE o pedido trouxer um site e o vídeo for SOBRE ele (lançamento, tour, case); vídeo que só cita a marca não precisa. '
+                + 'elementos: url — lê o CÓDIGO do site e lista as peças que dá para tirar (logo, menu, titulo, hero, botao, cartao, imagem, formulario, preco, rodape), cada uma com o seletor. '
+                + 'elemento: url + seletor (ou texto: o que está escrito nele) — tira SÓ aquela peça, em PNG com fundo transparente e no dobro da resolução, e devolve o código dela (html e estilo: fonte, cor, raio, sombra) e um elemento {tipo:"imagem"} pronto; '
+                + 'use para pôr o botão, o cartão de preço ou a logo do site animando no vídeo (ou redesenhe a peça como componente a partir do código). No vídeo 3D (estilo personagem), a peça ENTRA NA CENA em blocos: passe roteiro.objetos:[{nome:"logo", src:<o src devolvido>}] (até 3). '
+                + 'recortar: arquivo — tira o fundo de qualquer foto com IA (rembg), PNG transparente. '
+                + 'efeitos: lista os componentes guardados (os menos usados primeiro). usar-efeito {nome}: copia para o projeto e devolve o elemento — use se um deles servir a ESTE roteiro. '
+                + 'guardar-efeito {arquivo, nome, descricao}: guarda um componente que você escreveu e ficou bom, para os próximos vídeos '
+                + '(o componente: export default de uma função React que recebe {el, t, fps}, num arquivo só, importando só react, remotion, @remotion/*, three). '
+                + 'baixar: o número do item da busca (1 é o primeiro). transparente: true para PNG recortado. '
+                + 'icones: sem "nome", procura; com "nome" ("lucide:zap"), baixa. '
+                + 'Tudo é BAIXADO para a pasta do projeto — o plano nunca aponta para a internet.' },
+
+            { tool: 'estudio_ae', escreve: true, faz: 'monta e renderiza uma composição em After Effects (JSX, via EffectCraft), com keyframes, expressões e efeitos',
+              args: 'id. script (o JSX: app.project.items.addComp, camadas, setValueAtTime com ease). comp (o nome da composição). fontes [{familia, peso}]. '
+                + 'audio (caminho relativo, juntado ao vídeo). conferir [segundos]: quadros PNG para olhar antes de dar por pronto. Leia a skill after-effects. Sai em video-ae.mp4.' },
+            { tool: 'estudio_motion', escreve: true, faz: 'a máquina de motion: do assunto ao vídeo de motion pronto (cenas no After Effects, sons no tempo, trilha e voz opcionais, −14 LUFS)',
+              args: 'id. assunto. formato (9:16|1:1|16:9). duracao (6 a 60 s). receita (id de estudio_midia acao:"projetos": usa o formato e a duração da ficha). '
+                + 'marca {cores:{fundo,destaque,tinta}, fontes:{titulo,texto,destaque}}. cenas [{papel, tipo?, fala?, titulo, itens, valor, rotulo, antes, depois, texto, autor, botao}] (o diretor escolhe entre 38 primitivas, 15 transições, 8 câmeras e 8 tipografias, com assinatura própria; a palavra-chave vai entre *asteriscos*). '
+                + 'elementos (termos reais do assunto). transicoes. camera. tipografia. semente. voz (texto ou {}; o whisper mede cada palavra). trilha (true ou o que buscar; false desliga). Sem cenas, o diretor monta. Prefira esta a escrever JSX. Sai em video-motion.mp4. previa:true = rascunho em segundos (meia resolução, sem mix final) para aprovar antes do final. gosto:false pula a tela de gosto do primeiro pedido; o gosto salvo da pessoa (~/.primocode/gosto-motion.json) já entra como peso no diretor — trate como direção, não molde.' },
+            { tool: 'estudio_editar', escreve: true, faz: 'o editor por comando: muda um vídeo do estudio_motion (texto, cor, fonte, ritmo, cenas, trilha, volume, formato) e guarda versões',
+              args: 'id_video. mudancas [{op, ...}]: texto {cena,valor} · cor {fundo,destaque,tinta|paleta} · fonte {titulo,texto,destaque} · ritmo {fator} · duracao {cena,segundos|total} · remover/mover/duplicar {cena,para} · trilha {valor:false|busca} · volume {alvo:voz|trilha|sfx,db} · formato {valor}. '
+                + 'previa (rascunho rápido). final (render final da versão atual). voltar_para (n da versão). listar. "Deixa mais rápido" = ritmo fator 0.8; "tira a música" = trilha valor false. Sai em versoes/vN.' },
+            { tool: 'estudio_narrar', escreve: true, faz: 'gera a narração em voz neural e devolve o tempo MEDIDO de cada fala',
+              args: 'id. texto. voz (antonio|francisca|thalita). estilo (normal|anuncio|calmo|dramatico). '
+                + 'vozes: true lista as vozes. '
+                + 'Use os tempos que voltam para a duração das cenas — estimar por número de palavras erra em segundos.' },
+
+            { tool: 'editor_pro', escreve: true, faz: 'a EDIÇÃO COMPLETA de um vídeo falado da pessoa (o motor do EDIT IA PRO): corte da melhor tomada sem respiro, voz limpa e no volume, legenda animada, gancho, câmera viva, peças, b-roll, sons, trilha com ducking e portão de qualidade',
+              args: 'acao: editar | cortar | montar | preparar | estado. video (a gravação; o original nunca é tocado). pasta (a da edição, devolvida por cortar). prompt (nomes difíceis da fala). '
+                + 'cortar devolve a fala do corte com os tempos; com ela, montar recebe plano {gancho:"Texto *destaque*", pecas:[lettering|lista_check|passo_a_passo|contador|rotulo|carimbo...], broll:[{busca,de,ate,rotulo}], blocos?, estilo?, legenda?, correcoes?} e trilha (auto | arquivo | false). '
+                + 'Sai em <pasta>/final.mp4, só com o portão PASSOU. Leia a skill editar-video.' },
+            { tool: 'estudio_video', escreve: true, faz: 'o que se faz com a gravação do usuário: importar, medir, cortar silêncio, transcrever, recortar a pessoa',
+              args: 'id. acao: editar | camadas | importar | medir | silencio | cortar-silencio | quadro | legendas | recortar-pessoa. '
+                + 'editar: FAZ A EDIÇÃO INTEIRA sozinho — corta o silêncio, transcreve palavra por palavra e monta o plano '
+                + '(legenda animada, ícone na hora da palavra, zoom de corte, pop e whoosh). estilo: viral (padrão) | limpo. '
+                + 'Com gravação do usuário, é o PRIMEIRO passo depois de importar; depois só estudio_render. '
+                + 'arquivo: caminho (em "importar", de fora; nas outras, o relativo dentro do projeto). '
+                + 'cortar-silencio: minimoParaCortar (padrão 0.6s), respiro (padrão 0.18s) — os dois existem para o corte não soar robótico. '
+                + 'legendas: devolve os trechos com tempo, para virarem elemento "legenda". '
+                + 'recortar-pessoa: devolve um vídeo com fundo TRANSPARENTE, para pôr sobre qualquer fundo. '
+                + 'camadas: a pessoa SÓ GRAVOU A FALA e o motion vem por cima — a gravação contínua é a narração, o ROSTO muda de forma com mola '
+                + '(cheia | cartao | bolinha | some) e a cena de motion ocupa o espaço que sobra; legenda palavra por palavra (1 a 3), destaque em serif itálica na cor de acento. '
+                + 'Sem batidas, devolve uma PROPOSTA pela transcrição; você decide e chama de novo com '
+                + 'batidas:[{de, ate, rosto, cena?: "componentes/x.jsx" ou nome de efeito de fábrica, destaque?: ["palavra"], canto?: esquerda|direita|centro (bolinha), dados?: {…} para a cena}]. '
+                + 'Alterne as formas, ponha cena onde o rosto encolhe e varie as cenas. rosto: {foco:{x,y} (0 a 1, onde o rosto está na gravação), zoom} quando a pessoa está longe. acento: "#RRGGBB".' },
+
+            { tool: 'estudio_render', escreve: true, faz: 'vira arquivo pelo Remotion e abre para o usuário: .mp4 no vídeo, .pdf em slides e arte',
+              args: 'id. paginas: true força páginas paradas em vez de vídeo (projeto de formato "slides" ou "arte" já faz isso sozinho). '
+                + 'somenteProjeto: true escreve o projeto Remotion sem renderizar. minutos (padrão 30). '
+                + 'A primeira render de um projeto instala o Remotion na pasta dele (alguns minutos, uma vez). '
+                + 'Slide é uma CENA PARADA: o mesmo plano, as mesmas primitivas, e a página sai do quadro do MEIO da cena — '
+                + 'do primeiro sairia em branco, com a animação de entrada ainda fora do quadro.' },
+
+            { tool: 'estudio_site', escreve: false, faz: 'lê a identidade visual de uma marca: cores, fontes, logo e o que ela diz de si',
+              args: 'url — OU marca: o nome da empresa, quando não há link ("faça um vídeo para a Paris Group"). '
+                + 'id (opcional): anota no caderno do projeto — e com id traz o ACERVO da marca: as fotos e os vídeos '
+                + 'reais do site (que entram sozinhos no vídeo) e os FATOS das páginas (datas, local, números), para o roteiro. '
+                + 'Devolve FATOS medidos, não um roteiro — o roteiro é seu. '
+                + 'Use SEMPRE que o pedido citar uma empresa de verdade: inventar a cor de uma marca que existe '
+                + 'é erro que sai pronto no vídeo entregue. '
+                + 'Com id, BAIXA a logo para midia/ e devolve o src pronto — leia o "aviso" dela antes de usar: '
+                + 'a logo pode ser o símbolo monocromático, ou uma imagem que não é logo nenhuma.' },
+
+            { tool: 'planejar_producao', escreve: false, noLoop: true,
+              faz: 'ativa o DIRETOR: arco, narração cena a cena, voz, direção de arte, mídia a buscar e trilha — a estrutura ANTES de produzir',
+              args: 'pedido: o que produzir, como o usuário falou. segundos (opcional, padrão 30). '
+                + 'formato (opcional): video | apresentacao. contexto (opcional): o que você já apurou (identidade da marca, o que o site diz). '
+                + 'Devolve a PAUTA em prosa, mais voz, mídia a buscar e trilha. '
+                + 'Chame ANTES de estudio_plano em qualquer peça que tenha narração ou mais de três cenas: '
+                + 'quem monta o JSON das cenas gasta a atenção no JSON, e é ali que o roteiro vira legenda '
+                + '("Vantagens", "Nossos serviços") em vez de virar fala. '
+                + 'A pauta é para LER e compor com as primitivas — não copie os campos dela para dentro do plano.' },
+        ],
+    },
+    {
+        /* MCP primeiro, mouse por último: o serviço pela API dele (Notion,
+           GitHub, Slack…) é uma chamada; o mesmo pela tela são vinte cliques. */
+        nome: 'Conectores',
+        resumo: 'MCP: age num serviço ou app pela API dele, sem mouse — procura, conecta e usa',
+        itens: [
+            { tool: 'mcp_procurar', escreve: false, faz: 'acha o servidor MCP de um serviço (lista curada + registro oficial)',
+              args: 'busca: o serviço ou app, ex "notion", "github", "planilha".' },
+            { tool: 'mcp_conectar', escreve: false, faz: 'instala, sobe e valida um servidor MCP — pede autorização antes',
+              args: 'nome: curto, ex "notion" (curado: só o nome basta). comando (opcional) e args (opcional, lista): do "instalar" do mcp_procurar. env (opcional, objeto): as chaves que o servidor pede — sem elas, pergunte ao usuário.' },
+            { tool: 'mcp_usar', escreve: false, faz: 'chama uma ferramenta de um servidor MCP conectado',
+              args: 'servidor: nome do servidor. ferramenta: nome da tool dele. argumentos (opcional, objeto): os args da tool.' },
+        ],
+    },
+    {
+        nome: 'Computador',
+        resumo: 'janelas, botões, mouse e teclado — age em qualquer programa e na área de trabalho',
+        itens: [
+            { tool: 'desktop_open_app',      escreve: false, faz: 'abre um programa pelo nome (Chrome, Bloco de Notas…)',
+              args: 'app: nome do programa, como o usuário fala.' },
+            { tool: 'desktop_windows',       escreve: false, faz: 'lista as janelas abertas, com título', args: null },
+            { tool: 'desktop_focus',         escreve: false, faz: 'traz uma janela para a frente, pelo título',
+              args: 'window: título (ou pedaço único) da janela.' },
+            { tool: 'desktop_elements',      escreve: false, faz: 'lê os botões, campos e ícones da janela, com posição',
+              args: 'window (opcional): título da janela alvo; sem isso, a janela em foco. No Windows, "Program Manager" é a área de trabalho.' },
+            { tool: 'desktop_click_element', escreve: false, faz: 'clica num botão ou ícone pelo NOME, sem coordenada',
+              args: 'name: nome (ou pedaço) do botão/campo/ícone. window (opcional). double (opcional, bool, padrão false): clique duplo.' },
+            { tool: 'desktop_click',         escreve: false, faz: 'clica na tela por coordenada',
+              args: 'x, y (número). button (opcional: left|right, padrão left).' },
+            { tool: 'desktop_double_click',  escreve: false, faz: 'clique duplo — abre ícone da área de trabalho',
+              args: 'x, y (número).' },
+            { tool: 'desktop_move',          escreve: false, faz: 'move o mouse', args: 'x, y (número).' },
+            { tool: 'desktop_drag',          escreve: false, faz: 'arrasta de um ponto a outro',
+              args: 'from_x, from_y, to_x, to_y (número).' },
+            { tool: 'desktop_type',          escreve: false, faz: 'digita no programa que está na frente', args: 'text.' },
+            { tool: 'desktop_key',           escreve: false, faz: 'aperta tecla ou atalho (Enter, ctrl+c, alt+tab)',
+              args: 'key: tecla ou atalho, ex "Enter", "ctrl+c", "ctrl+shift+t", "alt+tab", "win".' },
+            { tool: 'desktop_scroll',        escreve: false, faz: 'rola a tela', args: 'dy (opcional, número, padrão 300).' },
+            { tool: 'desktop_size',          escreve: false, faz: 'mede a tela, para se orientar antes de clicar', args: null },
+            { tool: 'desktop_screenshot',    escreve: true,  faz: 'tira foto da sua tela',
+              args: 'path (opcional): onde salvar. Sem path, usa um nome padrão.' },
+        ],
+    },
+    {
+        nome: 'Organização',
+        resumo: 'como ele se organiza numa tarefa grande',
+        itens: [
+            { tool: 'write_todos', escreve: false, faz: 'monta o plano e vai marcando o que terminou',
+              args: 'todos: lista de {content: a tarefa curta no imperativo, status: pending|in_progress|completed}. Reescreve a lista inteira a cada chamada; só uma "in_progress" por vez.' },
+            { tool: 'perguntar', escreve: false, faz: 'pergunta ao usuário com 2 a 4 opções — só quando está bloqueado',
+              args: 'pergunta. opcoes: lista de 2 a 4 textos curtos (a recomendada primeiro). texto_livre (opcional, padrão true).' },
+            { tool: 'buscar_web', escreve: false, faz: 'busca na internet e devolve links com trecho',
+              args: 'consulta: poucas palavras. limite (opcional, número, padrão 6).' },
+            { tool: 'ler_url', escreve: false, faz: 'abre um link e devolve o texto da página em markdown',
+              args: 'url: link completo. max_chars (opcional), desde (opcional, número: continua uma leitura cortada).' },
+            { tool: 'agentes_buscar', escreve: false, faz: 'acha o especialista certo no catálogo de 100+ agentes (ou traz o briefing de um)',
+              args: 'consulta: o que você precisa, em poucas palavras. ver (opcional): id de um agente para ler o briefing completo. Sem argumentos: lista as áreas.' },
+            { tool: 'capacidade_buscar', escreve: false, faz: 'acha uma receita pronta entre 1000+ (22 grupos: git, shell, depuração, código, frontend, backend, banco, devops, testes, mobile, ia-llm, design, video-motion, marketing, produto-negocio, windows-linux, web, segurança…)',
+              args: 'consulta: a tarefa. grupo (opcional): limita a um grupo. Sem argumentos: lista os grupos.' },
+            { tool: 'pesquisar_referencia', escreve: false, faz: 'lê docs e exemplos antes de escrever — sobe a qualidade',
+              args: 'consulta: o que pesquisar, de preferência em inglês. paginas (opcional, número, padrão 3, máximo 5).' },
+            // Vai para memory-geral.md, FORA da pasta do projeto — por isso não
+            // é write_file/edit_file (a sandbox de resolveInProject bloqueia
+            // qualquer caminho fora do projeto, e é assim mesmo que tem que
+            // ser para os outros casos). Esta tool é a única porta pra lá.
+            { tool: 'remember_general', escreve: false, faz: 'grava algo sobre o usuário que vale para todo projeto (memory-geral.md)',
+              args: 'fato: o que lembrar, em uma frase.' },
+            { tool: 'lembrar', escreve: false, faz: 'guarda ou apaga uma memória que dura entre sessões (~/.primocode/memoria/)',
+              args: 'acao: salvar ou apagar. nome: kebab-case curto (mesmo nome atualiza). descricao: uma linha. tipo: usuario|feedback|projeto|referencia. texto: o fato (nunca chave, token ou senha).' },
+            // A troca de pasta pede o SIM do usuário, e quem pergunta é o bin:
+            // por isso o loop (lib/session/runner/act.js) atende, não o tools.execute.
+            { tool: 'mudar_pasta', escreve: false, noLoop: true,
+              faz: 'troca a pasta de trabalho para outra que o usuário citou — só depois do sim dele',
+              args: 'caminho: a pasta (absoluto, ~/…, ou o nome de um projeto). motivo: uma frase do porquê, aparece na pergunta ao usuário. '
+                + 'Para só LER lá não precisa trocar: read_file/list_dir com o caminho absoluto, glob/grep com padrão absoluto.' },
+            // Estas duas o loop do agente atende (lib/session/runner/act.js), não o tools.execute.
+            { tool: 'spawn_agent', escreve: false, faz: 'chama um subagente especialista para uma parte da tarefa', noLoop: true,
+              args: 'description: 3 a 5 palavras, aparece na tela do usuário. prompt: instrução completa e autossuficiente — o subagente não vê esta conversa. especialista (opcional): id EXATO que agentes_buscar devolveu — não chute o nome (o mais específico vence: css-layout, pagamentos, kubernetes, regex…, não frontend/backend/devops) ou dois separados por vírgula — cada um chega com o briefing da profissão (lib/skill/especialistas.js); sem ele, a tarefa sugere. agente (opcional): nome de um agente da pessoa (@nome); ganha do especialista.' },
+            { tool: 'construir_app', escreve: true, noLoop: true,
+              faz: 'constrói um app ou site inteiro com quatro papéis: engenheiro de prompt → protótipo → MVP → revisor que testa escondido, em laço até passar',
+              args: 'pedido: o que o usuário quer, com as palavras dele. pasta (opcional): onde construir — sem ela, uma pasta nova com o nome do pedido. rodadas (opcional, 1 a 4, padrão 2): quantas voltas de correção. '
+                + 'USE quando pedirem um app, um site, uma página ou uma ferramenta INTEIRA, do zero. NÃO use para mexer no que já existe, para um arquivo só, nem para conserto: são seis a oito chamadas de agente, '
+                + 'e gastá-las para trocar a cor de um botão come o dia do usuário. O revisor ABRE a página num navegador invisível e mede — página em branco e erro de JavaScript reprovam sozinhos, o que ele achar volta para o construtor.' },
+            { tool: 'finish',      escreve: false, faz: 'encerra dizendo o que fez', noLoop: true,
+              args: 'summary (opcional): uma frase do que foi feito.' },
+        ],
+    },
+];
+
+/** Só as que criam ou mudam arquivo. É o gatilho da pasta de projeto. */
+const ESCREVEM = new Set(
+    GRUPOS.flatMap((g) => g.itens.filter((i) => i.escreve).map((i) => i.tool)),
+);
+
+const TODAS = GRUPOS.flatMap((g) => g.itens.map((i) => i.tool));
+
+/** Esta ferramenta cria ou muda arquivo? */
+function escreveArquivo(tool) {
+    return ESCREVEM.has(tool);
+}
+
+/* ── O QUE FAZ NASCER UMA PASTA DE PROJETO ──────────────────────────────
+ * "Ela deve saber quando criar pasta do projeto e quando não criar — só vai
+ * criar quando fizer código." `escreve` era largo demais para isso: um print
+ * de tela, uma narração do estúdio e um vídeo também escrevem arquivo, e cada
+ * um deles criava um projeto com o nome da frase. Aqui só o que é CÓDIGO:
+ * escrever ou editar arquivo, montar um app, delegar a um especialista, e o
+ * comando de terminal que cria arquivo (o agente que faz `npm create` ou
+ * `mkdir` estava pondo o projeto solto na raiz de ~/primocode). */
+const CRIAM_PROJETO = new Set(['write_file', 'edit_file', 'multi_edit', 'construir_app', 'spawn_agent']);
+const SHELL_QUE_CRIA = /\b(mkdir|touch|git\s+clone|npm\s+(init|create)|npx\s+(create-|degit|nuxi\s+init)|yarn\s+create|pnpm\s+(create|dlx\s+create-)|bun\s+create|cargo\s+(new|init)|python3?\s+-m\s+venv|django-admin\s+startproject|rails\s+new|flutter\s+create|dotnet\s+new|composer\s+create-project|expo\s+init)\b|(^|[^<>&|0-9])>>?\s*[\w./~-]/;
+
+function criaProjeto(tool, args) {
+    if (CRIAM_PROJETO.has(tool)) return true;
+    if (tool === 'run_shell' || tool === 'run_in_new_terminal' || tool === 'run_background') {
+        return SHELL_QUE_CRIA.test(String((args && (args.command || args.comando)) || ''));
+    }
+    return false;
+}
+
+
+/**
+ * As ferramentas de nome mais parecido com o que foi chamado.
+ *
+ * Serve a um caso só, e ele é real: o modelo chamou uma tool que não existe.
+ * Isso acontece quando a lista que o servidor oferece diverge deste catálogo
+ * — foi o que houve quando o Estúdio trocou de vocabulário e o servidor
+ * continuou oferecendo `studio_criar` e `studio_listar`. Sem esta lista, a
+ * resposta ao modelo era "Tool não implementada", ele não tinha como saber o
+ * que existe, e dizia ao usuário que a ferramenta "não está disponível".
+ *
+ * A semelhança é por prefixo e por pedaço de nome, não por distância de
+ * edição: os erros reais são de FAMÍLIA ("studio_criar" quando o certo é
+ * "estudio_plano"), não de digitação.
+ */
+function parecidasCom(nome) {
+    const alvo = String(nome || '').toLowerCase().replace(/^estudio_|^studio_/, '');
+    const familia = /^e?studio_/.test(String(nome || '').toLowerCase());
+    const pontos = TODAS.map((t) => {
+        let p = 0;
+        if (familia && /^estudio_|^planejar_/.test(t)) p += 3;
+        const semPrefixo = t.replace(/^estudio_/, '');
+        if (semPrefixo === alvo) p += 10;
+        else if (semPrefixo.includes(alvo) || alvo.includes(semPrefixo)) p += 5;
+        // pedaços em comum (criar/listar/plano/midia…)
+        for (const parte of alvo.split('_')) {
+            if (parte.length >= 4 && t.includes(parte)) p += 2;
+        }
+        return { t, p };
+    }).filter((x) => x.p > 0).sort((a, b) => b.p - a.p);
+    // Sem nada parecido, a resposta honesta é o grupo inteiro a que ele
+    // provavelmente queria chegar — melhor que uma lista vazia.
+    if (!pontos.length) {
+        return familia ? TODAS.filter((t) => /^estudio_|^planejar_/.test(t)) : TODAS.slice(0, 8);
+    }
+    return pontos.slice(0, 6).map((x) => x.t);
+}
+
+module.exports = { criaProjeto,
+    parecidasCom, GRUPOS, TODAS, ESCREVEM, escreveArquivo };

package/lib/skill/marketplace.js

@@ -0,0 +1,189 @@
+/**
+ * marketplace.js — a tela das skills, navegável pelas setas.
+ *
+ *   "/marketplace abre uma tela navegável no terminal, com navegação pelas
+ *    setas, seções (uma delas é a seção de Skills) e rolagem para baixo. O
+ *    usuário navega, ativa e instala skills ali. Dentro do marketplace existe
+ *    a opção 'New Skill': seleciona com as setas, dá Enter, e o terminal pede
+ *    em sequência o nome e o conteúdo da skill."
+ *
+ * ── O DESENHO É FUNÇÃO PURA, DE NOVO ─────────────────────────────────────
+ * `montar()` recebe um estado e devolve linhas. `andar()` recebe uma tecla e
+ * devolve o estado seguinte. Nenhuma das duas toca no terminal nem no disco.
+ *
+ * É o mesmo desenho do `/effort` e da caixa de digitar, e pelo mesmo motivo:
+ * uma tela de terminal que só existe enquanto alguém aperta seta é uma tela
+ * que ninguém consegue testar. Assim o teste percorre a lista inteira, abre e
+ * fecha seção, rola até o fim e confere o que apareceu — sem nada na tela.
+ *
+ * ── POR QUE A LISTA É PLANA POR DENTRO ───────────────────────────────────
+ * A tela tem seções, mas a navegação é UMA lista: título de seção é item que
+ * não se escolhe, e a seta pula por cima dele. Tentar navegar em árvore (seta
+ * para entrar, outra para sair) é o tipo de coisa que exige explicação — e
+ * uma tela que precisa de manual não serve para quem abriu o terminal para
+ * fazer outra coisa.
+ *
+ * ── O QUE ESTE MARKETPLACE NÃO É ─────────────────────────────────────────
+ * Não há loja na internet. O catálogo é o que vem no produto mais o que
+ * estiver instalado na máquina, e é isso que a tela mostra — sem inventar um
+ * "1.248 skills disponíveis" que não existe. O dia em que existir um índice
+ * remoto, ele entra como mais uma seção.
+ */
+
+'use strict';
+
+const { c, truncate, padRight, visibleWidth } = require('../tui/ui.js');
+
+// ── o estado ─────────────────────────────────────────────────────────────
+
+/**
+ * @param {Array} skills  o que `skills.listar()` devolveu
+ */
+function novo(skills) {
+    // A seleção nasce no primeiro item ESCOLHÍVEL, não no zero — o zero é um
+    // título de seção, e uma tela que abre sem nada marcado parece travada.
+    const base = { skills: skills || [], sel: 0, topo: 0, saiu: null };
+    const lista = itens(base);
+    base.sel = escolhivel(lista[0]) ? 0 : proximo(lista, 0, 1);
+    return base;
+}
+
+/**
+ * A lista plana: cabeçalhos de seção e itens, na ordem em que aparecem.
+ *
+ * Cada item diz o que é e o que fazer com ele. A tela e as teclas leem daqui,
+ * então não existe a chance de uma delas achar que o terceiro item é outro.
+ */
+function itens(estado) {
+    const lista = [];
+    const ligadas = estado.skills.filter((s) => s.ligada);
+    const desligadas = estado.skills.filter((s) => !s.ligada);
+
+    lista.push({ tipo: 'secao', texto: 'Skills ativas', conta: ligadas.length });
+    if (!ligadas.length) lista.push({ tipo: 'vazio', texto: 'nenhuma ativa' });
+    for (const s of ligadas) lista.push({ tipo: 'skill', skill: s });
+
+    lista.push({ tipo: 'secao', texto: 'Desligadas', conta: desligadas.length });
+    if (!desligadas.length) lista.push({ tipo: 'vazio', texto: 'nenhuma desligada' });
+    for (const s of desligadas) lista.push({ tipo: 'skill', skill: s });
+
+    lista.push({ tipo: 'secao', texto: 'Criar' });
+    lista.push({ tipo: 'nova', texto: 'New Skill', detalhe: 'escreva a sua — o nome e o prompt' });
+    lista.push({ tipo: 'instalar', texto: 'Instalar de um arquivo', detalhe: 'um SKILL.md que você tem no disco' });
+
+    return lista;
+}
+
+/** Dá para parar em cima deste item? Título de seção e vazio, não. */
+const escolhivel = (item) => item && item.tipo !== 'secao' && item.tipo !== 'vazio';
+
+/** O primeiro item escolhível a partir de `de`, andando em `passo`. */
+function proximo(lista, de, passo) {
+    let i = de;
+    for (let n = 0; n < lista.length; n++) {
+        i += passo;
+        if (i < 0) i = lista.length - 1;
+        if (i >= lista.length) i = 0;
+        if (escolhivel(lista[i])) return i;
+    }
+    return de;
+}
+
+/**
+ * Uma tecla → o estado seguinte.
+ *
+ * Devolve `{ estado, acao }`. A ação é o que o mundo lá fora precisa fazer —
+ * ligar uma skill, abrir o diálogo de criar, sair. Este módulo não faz nada
+ * disso: ele não sabe gravar arquivo nem perguntar nada.
+ */
+function andar(estado, tecla, { altura = 14 } = {}) {
+    const lista = itens(estado);
+    const e = { ...estado };
+
+    // O primeiro pouso: se a seleção caiu num título, desce até um item.
+    if (!escolhivel(lista[e.sel])) e.sel = proximo(lista, e.sel, 1);
+
+    const nome = (tecla && tecla.name) || '';
+
+    if (nome === 'down' || nome === 'j') e.sel = proximo(lista, e.sel, 1);
+    else if (nome === 'up' || nome === 'k') e.sel = proximo(lista, e.sel, -1);
+    else if (nome === 'pagedown') { for (let i = 0; i < 5; i++) e.sel = proximo(lista, e.sel, 1); }
+    else if (nome === 'pageup') { for (let i = 0; i < 5; i++) e.sel = proximo(lista, e.sel, -1); }
+    else if (nome === 'home') { e.sel = proximo(lista, lista.length - 1, 1); }
+    else if (nome === 'end') { e.sel = proximo(lista, 0, -1); }
+    else if (nome === 'escape' || nome === 'q') return { estado: { ...e, saiu: 'fechar' }, acao: { tipo: 'fechar' } };
+    else if (nome === 'return' || nome === 'enter' || (tecla && tecla.sequence === ' ')) {
+        const item = lista[e.sel];
+        if (!item) return { estado: e, acao: null };
+        if (item.tipo === 'skill') {
+            return { estado: e, acao: { tipo: 'alternar', skill: item.skill } };
+        }
+        if (item.tipo === 'nova') return { estado: { ...e, saiu: 'nova' }, acao: { tipo: 'nova' } };
+        if (item.tipo === 'instalar') return { estado: { ...e, saiu: 'instalar' }, acao: { tipo: 'instalar' } };
+    }
+
+    // A janela acompanha a seleção: sem isto, descer faz o item escolhido
+    // sumir embaixo e a seta parece ter parado de funcionar.
+    const visiveis = Math.max(4, altura);
+    if (e.sel < e.topo) e.topo = e.sel;
+    if (e.sel >= e.topo + visiveis) e.topo = e.sel - visiveis + 1;
+    e.topo = Math.max(0, Math.min(e.topo, Math.max(0, lista.length - visiveis)));
+
+    return { estado: e, acao: null };
+}
+
+// ── o desenho ────────────────────────────────────────────────────────────
+
+function montar(estado, { colunas = 80, altura = 14 } = {}) {
+    const larg = Math.max(40, Math.min(colunas - 1, 110));
+    const lista = itens(estado);
+    const visiveis = Math.max(4, altura);
+    const topo = Math.max(0, Math.min(estado.topo || 0, Math.max(0, lista.length - visiveis)));
+
+    const out = [];
+    out.push('');
+    out.push('  ' + c.bold(c.brand('Marketplace')) + c.dim('  ·  as skills do Primo Code'));
+    out.push('  ' + c.dim('─'.repeat(larg - 4)));
+
+    for (let i = topo; i < Math.min(lista.length, topo + visiveis); i++) {
+        const item = lista[i];
+        const escolhido = i === estado.sel;
+        const seta = escolhido ? c.brand('❯ ') : '  ';
+
+        if (item.tipo === 'secao') {
+            // Linha em branco antes da seção, menos na primeira: é o que
+            // separa os grupos sem precisar de moldura.
+            if (out.length > 3) out.push('');
+            out.push('  ' + c.bold(c.white(item.texto))
+                + (item.conta != null ? c.dim(`  ${item.conta}`) : ''));
+            continue;
+        }
+        if (item.tipo === 'vazio') { out.push('    ' + c.dim(item.texto)); continue; }
+
+        if (item.tipo === 'skill') {
+            const s = item.skill;
+            const marca = s.ligada ? c.ok('●') : c.dim('○');
+            const titulo = escolhido ? c.bold(c.white(s.titulo)) : c.white(s.titulo);
+            const selo = s.doProduto ? c.dim('  do produto') : c.brandDim('  sua');
+            out.push('  ' + seta + marca + ' ' + truncate(titulo + selo, larg - 8));
+            // A descrição só aparece no que está selecionado: com ela em
+            // todas, a lista dobra de altura e ninguém lê nenhuma.
+            if (escolhido && s.descricao) {
+                out.push('      ' + c.dim(truncate(s.descricao, larg - 8)));
+            }
+            continue;
+        }
+
+        const titulo = escolhido ? c.bold(c.brand(item.texto)) : c.brandDim(item.texto);
+        out.push('  ' + seta + titulo);
+        if (escolhido && item.detalhe) out.push('      ' + c.dim(item.detalhe));
+    }
+
+    out.push('');
+    out.push('  ' + c.dim('─'.repeat(larg - 4)));
+    out.push('  ' + c.dim('↑↓ navega · Enter liga e desliga · Esc fecha'));
+    out.push('');
+    return out.join('\n');
+}
+
+module.exports = { novo, itens, andar, montar, escolhivel, proximo };