sapiens-mcp 1.41.0 → 1.43.0

package/dist/index.js

@@ -6,11 +6,12 @@
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { MCP_VERSION } from "./version.js";
 import { buildToolList, callTool, SAPIENS_INSTRUCTIONS, TOOLS, } from "./registry.js";
 import { getCachedTier, onTierVisibilityChange, probeTierInBackground, } from "./tier.js";
 import { getPrompt, listPrompts } from "./prompts.js";
+import { listSkillResources, readSkillResource } from "./skills.js";
 import { convexMutation, getSessionToken } from "./convexClient.js";
 // Telemetria stdio (fire-and-forget, NUNCA derruba a chamada). O stdio sempre
 // foi caixa-preta (cada cliente roda a própria cópia via npx), então o
@@ -44,12 +45,28 @@ function logStdioUsage(fields) {
 // login local em disco (cache de processo + probe no boot) e muda por
 // notifications/tools/list_changed.
 const server = new Server({ name: "mcp-sapiens", version: MCP_VERSION }, {
-    capabilities: { tools: { listChanged: true }, prompts: {} },
+    capabilities: {
+        tools: { listChanged: true },
+        prompts: {},
+        resources: {},
+    },
     instructions: SAPIENS_INSTRUCTIONS,
 });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: buildToolList(getCachedTier()),
 }));
+// As skills da casa também como RESOURCE (skill://sapiens/<slug>/SKILL.md).
+// Conteúdo estático do pacote: não exige login, não custa, não toca o backend.
+// Cliente que não lê resources pega o mesmo texto pela tool sapiens_skill.
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: listSkillResources(),
+}));
+server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+    const found = readSkillResource(req.params.uri);
+    if (!found)
+        throw new Error(`Resource desconhecido: ${req.params.uri}`);
+    return found;
+});
 server.setRequestHandler(ListPromptsRequestSchema, async () => ({
     prompts: listPrompts(),
 }));

package/dist/registry.js

@@ -29,7 +29,9 @@ import { atlas, atlasSchema } from "./tools/atlas.js";
 import { reference, referenceSchema } from "./tools/reference.js";
 import { trilhas, trilhasSchema } from "./tools/trilhas.js";
 import { shareDrop, shareDropSchema } from "./tools/shareDrop.js";
+import { skill, skillSchema } from "./tools/skill.js";
 import { describeConvexError } from "./convexClient.js";
+import { skillMenuLine } from "./skills.js";
 /**
  * REGISTRY compartilhado do sapiens-mcp: o catálogo de tools (descriptions +
  * schemas + handlers), as instructions da casa e o dispatch. Fonte ÚNICA usada
@@ -44,7 +46,7 @@ export const TOOLS = {
         handler: pipeline,
     },
     sapiens_image: {
-        description: "Operações de imagem via Sapiens (Gemini, Azure gpt-image-2, Grok, Veo). Sub-actions: 'generate' (gera imagem completa imediato — prompt+model+aspectRatio+size; suporta mode=edit/variation e MULTI-REFERÊNCIA: combine até 4 imagens como referência numa geração só, igual ao modal 'Selecionar Referência' do web — via referenceImageUrls (sua galeria + Acervo + personagens públicos de sapiens_character) e/ou sourceImageIds (ids da sua galeria); refs valem pros modelos robustos nano-banana-2/gpt-image-2-*/grok-2-image*), 'request_generation' (cria APENAS row pendente em generatedImages + debita créditos — pra modelos sapiens-video-* ANTES de sapiens_shorts/sapiens_video; whitelist, rate limit 3/min), 'compose' (combina persona+screen via Gemini pra app-demo Shorts; 25 sinapses, rate limit 10/min). generate=image one-shot, request_generation=criar row video, compose=montar start frame app-demo. TEMPLATE: passe templateSlug numa generate pra usar um super-prompt travado da casa — o `prompt` vira só a CENA (quem + pose + objeto-conceito) e o template embrulha estilo+fundo+enquadramento+ref de traço. 'retrato-sapiens-v1' = retrato editorial cartoon de um personagem no grid verde Sapiens (mesma 'mão' dos artigos); sem ref própria, injeta a Helen como âncora de traço (passar referenceImageUrls troca quem aparece). Mutuamente exclusivo com brandSlug. Sub-action 'models' (sem custo, sem login): lista o catálogo vivo (modelos ativos + preço atual com override admin + maxResolution + se aceita referência) pra descobrir modelo/preço em vez de chutar. NOTA: generate é SÍNCRONA e cobra ao concluir; modelo pesado (Pro, gpt-image-2-high, Grok quality, 2K/4K) cai na REGRA DO TIMEOUT (cheque sapiens_gallery action=list antes de repetir, evita cobrança dupla).",
+        description: "Operações de imagem via Sapiens (Gemini, Azure gpt-image-2, Grok, Seedream/ByteDance, Veo). Sub-actions: 'generate' (gera imagem completa imediato — prompt+model+aspectRatio+size; suporta mode=edit/variation e MULTI-REFERÊNCIA: combine até 4 imagens como referência numa geração só, igual ao modal 'Selecionar Referência' do web — via referenceImageUrls (sua galeria + Acervo + personagens públicos de sapiens_character) e/ou sourceImageIds (ids da sua galeria); refs valem pros modelos robustos nano-banana-2/gpt-image-2-*/grok-2-image*/seedream-*), 'request_generation' (cria APENAS row pendente em generatedImages + debita créditos — pra modelos sapiens-video-* ANTES de sapiens_shorts/sapiens_video; whitelist, rate limit 3/min), 'compose' (combina persona+screen via Gemini pra app-demo Shorts; 25 sinapses, rate limit 10/min). generate=image one-shot, request_generation=criar row video, compose=montar start frame app-demo. TEMPLATE: passe templateSlug numa generate pra usar um super-prompt travado da casa — o `prompt` vira só a CENA (quem + pose + objeto-conceito) e o template embrulha estilo+fundo+enquadramento+ref de traço. 'retrato-sapiens-v1' = retrato editorial cartoon de um personagem no grid verde Sapiens (mesma 'mão' dos artigos); sem ref própria, injeta a Helen como âncora de traço (passar referenceImageUrls troca quem aparece). Mutuamente exclusivo com brandSlug. Sub-action 'models' (sem custo, sem login): lista o catálogo vivo (modelos ativos + preço atual com override admin + maxResolution + se aceita referência) pra descobrir modelo/preço em vez de chutar. NOTA: generate é SÍNCRONA e cobra ao concluir; modelo pesado (Pro, gpt-image-2-high, Grok quality, 2K/4K) cai na REGRA DO TIMEOUT (cheque sapiens_gallery action=list antes de repetir, evita cobrança dupla).",
         schema: imageSchema,
         handler: image,
     },
@@ -53,13 +55,18 @@ export const TOOLS = {
         schema: metaSchema,
         handler: meta,
     },
+    sapiens_skill: {
+        description: "As SKILLS da casa: o passo a passo travado de cada fluxo do Sapiens, servido pelo próprio connector (sem login, sem custo, sem rede). LEIA A SKILL ANTES DE OPERAR O FLUXO — é mais barato que errar uma geração que cobra Sinapses. Sub-actions: 'list' (índice: slug + quando usar cada uma), 'get' (o SKILL.md inteiro, passe name=<slug>). Slugs: primeiros-passos (porta de entrada e as 4 armadilhas: timeout que já cobrou, disjuntor anti-loop, saldo, sessão), voz-da-casa (DNA editorial, leia antes de redigir qualquer texto publicável), musica (Musicator em 4 passos + efeito sonoro), video (qual modelo, iterar barato no Mini, storyboard por referência, sonorize), imagem (prompt full-bleed na régua da casa, multi-referência, templates), studio (gerar na identidade da pessoa vs base, e a Emancipação), tirinha (2 fases, a imagem sai SEM texto), forum-comunidade (mídia estruturada, menção, tese), companhia (o Sintético veste você), trilhas (missão e prova). O mesmo conteúdo também sai como resource MCP em skill://sapiens/<slug>/SKILL.md pra quem lê resources.",
+        schema: skillSchema,
+        handler: skill,
+    },
     sapiens_repertorio: {
         description: "Acervo pessoal de filme/série/anime/jogo/livro/música (Repertório, o segundo cérebro do user). Reads: list (filtros mediaType/status), search (texto em title/genres/tags), get (detalhe), popArticles, resolve (busca capa/ano/id nos providers server-side: OMDb/IGDB-Twitch/AniList/Google Books/iTunes). Mutations (qualquer logado, mexem no PRÓPRIO acervo): add_item, update_item (status/rating/tags/note/isPublic), remove_item. CAPTURA ONE-SHOT travada na lista de providers: quando o user fala natural ('acabei de ver Duna 2, nota 9', 'tô jogando Hollow Knight', 'li tal livro'), (1) infira mediaType e status (assisti/zerei/li=completed, quero=backlog, tô jogando/vendo=active, dropei=dropped) e rating se citado; (2) chame action=resolve {mediaType, query}, escolha o candidato certo e faça add_item passando SÓ o source + externalId DELE + os campos pessoais (status/rating/tags/note). O servidor re-resolve no provider e grava título/capa/ano canônicos — você NÃO manda título/capa nem inventa externalId. (3) Se o resolve não achar (lista vazia/providerKeyMissing), NÃO dá pra adicionar: diga ao user que não encontrou nos providers (não fabrique entry manual). Upsert/dedup por (userId, source, externalId). Só pergunte se ambíguo entre candidatos. FERRAMENTAS DE IA (Repertório de Ferramentas): fluxo separado (vêm do catálogo aitag, não dos providers de mídia). action=search_tools {query} acha a ferramenta no catálogo e devolve o toolId; action=add_tool {toolId, favorite?, rating?, note?} grava como mediaType 'tool' (estar no acervo já é 'usei'; favorite=true liga a estrela). Use quando o user fala 'adiciona o Midjourney/Cursor no meu repertório de ferramentas' ou 'uso tal ferramenta de IA'. Cada ferramenta aponta pra página dela no aitag.",
         schema: repertorioSchema,
         handler: repertorio,
     },
     sapiens_gallery: {
-        description: "Browse e publicação das imagens geradas pelo user (nanoBanana). Sub-actions: list (últimas N imagens, com prompt/model/url + isPublic), get (1 imagem com metadados, opcionalmente base64), publish (torna a PRÓPRIA imagem pública: entra na galeria pública + feed Pinterest, e ganha página indexável /imagem/<id> se o modelo não for degen — devolve publicPageUrl), unpublish (volta a privada). Use list/get pra reusar imagem como referência (passe o imageId em sapiens_image mode=edit ou mode=variation) ou pra mostrar pro user o que ele já tem; publish quando o user quer divulgar a imagem dele.",
+        description: "Browse, publicação e upload das imagens do user. Sub-actions: list (últimas N imagens, com prompt/model/url + isPublic), get (1 imagem com metadados, opcionalmente base64), publish (torna a PRÓPRIA imagem pública: entra na galeria pública + feed Pinterest, e ganha página indexável /imagem/<id> se o modelo não for degen — devolve publicPageUrl), unpublish (volta a privada), upload (traz pra galeria uma peça gerada FORA da casa, por sourceUrl https, filePath local ou base64; ADMIN por ora). Use list/get pra reusar imagem como referência (passe o imageId em sapiens_image mode=edit ou mode=variation) ou pra mostrar pro user o que ele já tem; publish quando o user quer divulgar a imagem dele. IMPORTANTE sobre upload: a peça entra PRIVADA e continua privada — o servidor recusa publicar e recusa compartilhar na comunidade, porque ela é do usuário e a responsabilidade é dele. O caminho pra ela virar coisa pública é usar como referência numa geração daqui e publicar o resultado.",
         schema: gallerySchema,
         handler: gallery,
     },
@@ -196,52 +203,26 @@ export const TOOLS = {
 // disjuntor anti-loop). Mantém curto de propósito: viaja em todo handshake.
 export const SAPIENS_INSTRUCTIONS = `Você opera o Sapiens Sintéticos (sapiensinteticos.com) NA CONTA de um usuário logado. Cada tool age de verdade na conta dele e muitas COBRAM Sinapses (o crédito da casa). Aja como operador, não no chute.
 
+AS SKILLS DA CASA (leia ANTES de operar, não improvise o fluxo):
+O passo a passo travado de cada fluxo mora na tool sapiens_skill, servida por este mesmo servidor: sem login, sem custo, sem rede. Ler a skill é mais barato que errar uma geração que cobra.
+- sapiens_skill action=list -> o índice (slug + quando usar cada uma).
+- sapiens_skill action=get name=<slug> -> a skill inteira.
+Slugs: ${skillMenuLine()}
+Puxe a skill ANTES de: gerar música ou efeito sonoro (musica), escolher modelo de vídeo (video), gerar imagem (imagem), criar na identidade do usuário (studio), montar tirinha (tirinha), postar no Fórum ou no chat (forum-comunidade), redigir qualquer texto publicável (voz-da-casa), incorporar o Sintético (companhia), missão de Desafio (trilhas). Perdido no começo: primeiros-passos.
+Cliente que lê resources MCP acha o MESMO conteúdo em skill://sapiens/<slug>/SKILL.md.
+
 REGRA DE OURO:
 - PRIMEIRO CONTATO ou "o que você faz?"/"como começo?"/"o que dá pra fazer?": chame sapiens_meta action=start e MOSTRE o resultado na sua voz. Sem login, ele ensina a conectar; logado, traz saldo + primeiros poderes com exemplos. É a porta de entrada: não despeje a lista inteira de tools, deixe o start guiar.
 - LOGO APÓS UM LOGIN BEM-SUCEDIDO (action=login retornou ok): chame action=start na sequência e mostre a porta de entrada. O recém-chegado não sabe o que pedir; não o deixe na tela em branco, guie a primeira jogada sem ele precisar perguntar.
 - Se um tool voltar erro de validação ("exige X", "falta Y"), LEIA o erro e refaça a chamada COM o que falta. NUNCA repita igual a chamada que falhou: 3 falhas seguidas no mesmo tool fazem o cliente marcar o servidor como "unreachable" por ~56s (disjuntor anti-loop). Aí parece que "o MCP caiu", quando foi só argumento faltando.
-- Antes de gerar algo caro (imagem/música/vídeo), cheque saldo: sapiens_meta action=credits (ou subscription). Saldo baixo, avise o usuário antes.
-- REGRA DO TIMEOUT (vale pra toda geração SÍNCRONA: imagem pesada, artigo, mega-gráfico, carrossel): a chamada pode estourar o teto de ~120s do cliente e voltar 'Timeout' MESMO tendo gerado e COBRADO. Nunca repita às cegas: confira antes onde o resultado cairia (imagem: sapiens_gallery action=list; artigo: sapiens_write action=list; pipeline: /dashboard/admin/content).
+- Antes de gerar algo caro (imagem/música/vídeo), cheque saldo: sapiens_meta action=credits (ou subscription). Saldo baixo, avise o usuário antes. Vídeo é o mais caro da casa: confirme com ele antes de disparar.
+- REGRA DO TIMEOUT (vale pra toda geração SÍNCRONA: imagem pesada, artigo, mega-gráfico, carrossel): a chamada pode estourar o teto de ~120s do cliente e voltar 'Timeout' MESMO tendo gerado e COBRADO. Nunca repita às cegas: confira antes onde o resultado cairia (imagem: sapiens_gallery action=list; artigo: sapiens_write action=list; carrossel: sapiens_pipeline action=list_carousels; pipeline: /dashboard/admin/content).
 - "sessionToken expirado" = refaça login: sapiens_meta action=login com o código de sapiensinteticos.com/conectar-claude.
-- sapiens_meta action=formats devolve os schemas por formato; action=whoami diz tier (user/admin) + saldo.
-
-FLUXOS QUE NÃO PODEM ERRAR:
-
-Música (sapiens_musicator) é fluxo de 4 passos, EM ORDEM:
-  1. create  exige title (≥3) + context (≥20 chars, o tema/ângulo) + direction (gênero/mood). Custo 0, devolve trackId.
-  2. lyrics  passe trackId + context pra GRAVAR a letra na track (300 Sinapses). NUNCA chame lyrics sem title+context.
-  3. render  passe o trackId pronto pra sintetizar o áudio (3000 Sinapses, assíncrono, 3/min).
-  4. get     passe o trackId e fique polando o status até 'ready' (ou 'failed').
-  Pular pro lyrics/render sem create, ou sem os campos, sempre falha.
-
-Efeito sonoro (sapiens_stock_audio): primeiro procure pronto (action=list kind=sfx, grátis). Não achou, action=generate: prompt + durationSeconds (1-15, default 5) + provider ('mirelo' padrão | 'elevenlabs' premium, custo por segundo) + promptInfluence opcional (0..1, só elevenlabs: fidelidade ao texto). Assíncrono: devolve generationId, acompanhe com action=generation-status até 'ready' (audioUrl) ou 'failed' (reembolsa sozinho). Efeito é CURTO; música inteira é no sapiens_musicator, não aqui.
-
-Sonorizar clipe (sapiens_video action=sonorize): dá som a um vídeo SEU já gerado (status completed). Passe imageId + prompt descrevendo o som da cena (ambiente, materiais, impactos); sai uma VARIANTE nova com trilha sincronizada ao movimento (MMAudio, 20 Sinapses/s do clipe, mín 100), o original fica intacto. Acompanhe com action=status no imageId NOVO que o sonorize devolve. Não re-sonorize uma variante: sonorize sempre o original.
-
-Vídeo (sapiens_video) action=create EXIGE 'model': sapiens-video-seedance | seedance-2-fast | seedance-2-mini | kling | wan | kling-motion | lite | fast | quality | omni. Sem model, falha de cara. Os três Seedance 2.0 têm o MESMO repertório (referência, frame inicial/final, vídeo de movimento, áudio nativo): o 'sapiens-video-seedance-2-mini' custa METADE do padrão e o '-2-fast' 20% menos, ambos com teto 720p. Iterar no Mini e fechar no padrão economiza Sinapses do usuário sem trocar de fluxo. O 'omni' (Gemini Omni) gera clipe de 10s 720p com áudio nativo a partir de TEXTO (não aceita imagem/vídeo do user, ignora duração/resolução) e EDITA os próprios vídeos: passe editOfImageId com o imageId de um vídeo Omni já gerado e o prompt vira instrução de edição sobre a MESMA cena (troca item/personagem, preserva câmera e ambiente; cada edição debita como geração nova). É o caminho pra variações com continuidade: gera a base uma vez, edita N vezes. Vídeo é o mais caro: confirme com o usuário antes. action=shadows (ADMIN, 200 Sinapses/segundo, refund na falha): passa videoUrl (URL pública) + title (+ durationSec se souber, pra cobrar proporcional; sem ela, flat ~2000) e o servidor extrai a SOMBRA (mapa de profundidade) do vídeo: ela cai na SUA timeline de vídeos (quem extrai vira dono, igual ao recorte de fundo na imagem) e vira ficha no Acervo (Corpo) como deepshadow reutilizável (driving pro Shot Mimic/Kling Motion). VÍDEOS PROGRAMÁTICOS (Estúdio de Vídeo, tela /experimentos/films): são OUTRA coisa, a mesa de filmes-de-código da casa, CINCO kinds na tabela videoSpecs: demo (UI clonada + câmera), aula-tour (telas reais + narração), essay (fita-ensaio abstrata: partícula/tinta vira símbolo; narração opcional, 16:9 ou 9:16), tipografia-musical (clipe tipográfico, a música dirige o corte) e dataviz (barras/números no tempo). O RENDER não sai deste MCP: um agente local (Claude Code, skill /film) produz o mp4 no repo da casa. Mas o CICLO na plataforma fecha por aqui (ADMIN, sem custo): film-list/film-get puxam os specs, film-upsert registra/atualiza, film-status cola a URL do render e marca pronto, film-publish põe no Acervo. User comum pedindo 'fita-ensaio'/'demo film': aponte pra tela e pro agente local.
-
-Imagem (sapiens_image) action=generate: prompt + model + aspectRatio. Referência via referenceImageUrls (galeria/Acervo/personagens) e/ou sourceImageIds. templateSlug aplica um super-prompt travado da casa. PROMPT na regra da casa: full-bleed, sujeito oversized (70%+ do frame), sem "tarot card"/"intimate scale"/moldura/margem. action=models (sem custo, sem login) lista os modelos ativos com o preço atual: consulte quando não tiver certeza do modelo ou do custo.
-
-SEU STUDIO vs geração BASE (não confunda, é o ponto): o usuário tem UM "Meu Studio", único, que o servidor resolve pela SESSÃO. Você NUNCA passa id de studio: é sempre o studio dele. É a identidade configurada dele: marca + personagem-operador + por ferramenta os presets e a "vibe" (o estilo afinado).
-- Criar SEGUINDO o studio (na cara dele): sapiens_image com useStudio=true. O servidor acha o studio e aplica marca + personagem + vibe + presets sozinho (o que você passar explícito vence). O retorno traz studioApplied=true. Use quando ele diz "no meu studio", "na minha marca", "do meu jeito", "como sempre".
-- Geração AVULSA (Sapiens base, sem a identidade dele): sapiens_image SEM useStudio (studioApplied=false). Pra teste solto ou pedido fora da identidade. Não misture: ou é studio, ou é base.
-- Antes de criar no studio, cheque com sapiens_studios action=mine (nível, marca, operador, ferramentas, a vibe da imagem). Se você pediu useStudio e voltar studioApplied=false, o user não tem studio montado: avise e aponte /dashboard/studio. Gerar no studio faz ele evoluir de nível.
-- EMANCIPAÇÃO (Nível 3, o passo grande): quando o membro quer a casa PRÓPRIA dele (site/produto próprio, FORA do Sapiens), use sapiens_studios action=emancipar. Ele devolve o blueprint pra VOCÊ construir na infra DO MEMBRO (Vercel + Convex + domínio dele), começando pela Fundação e seguindo um módulo por vez (action=module module=<slug>). Confirme cada passo, nunca hospede no Sapiens, siga o gosto dele. É complexo: conduza com calma.
-
-Tirinha / Comic (sapiens_pipeline format=tirinha + sapiens_image): fluxo de 2 FASES, decida o MODO antes de gerar pixel.
-  FASE 1 (roteiro): monte 3-6 painéis, cada um com a CENA visual e a FALA/legenda SEPARADAS. Salve em sapiens_pipeline create_production format=tirinha. O texto dos balões mora no payload (campos dialogue/caption), NUNCA dentro da imagem.
-  FASE 2 (imagem), escolha UM dos dois modos (pergunte ao user, ou decida pelo caso):
-  MODO A, tira inteira numa imagem só: UMA chamada sapiens_image com prompt em grade (descreva "Painel 1 (cima-esq): ...; Painel 2 (cima-dir): ...", peça grade NxM com calhas brancas finas, MESMO personagem/estilo/luz em todos os quadros). Mais barato, estilo mais travado, menos controle quadro a quadro.
-  MODO B, painel a painel (N imagens): UMA sapiens_image por painel, com character-lock passando o painel anterior + a ref da Helen em referenceImageUrls. Mais controle e consistência de enquadramento, custa N gerações.
-  REGRA DE OURO da tirinha: a imagem sai SEM texto (o estilo da casa é no-text e modelo de imagem erra letra). A fala vai SEPARADA como legenda: manda a imagem com a fala embaixo (ex no Telegram "Painel 1 · Helen: '...'"); os balões editáveis e a diagramação final ficam no comic-builder do dashboard (/experimentos/comic-builder). NÃO tente assar a fala dentro do prompt.
-
-Mídia no Fórum (PADRÃO, faça sempre assim): a peça vai EMBEDADA num card estruturado, nunca como "vai ouvir/ver noutro lugar". Música publicada (sapiens_musicator action=publish) já cria a tese no Fórum com a faixa tocável, não escreva "tá no Acervo, ouça lá". Pra anexar mídia a uma tese sua: sapiens_forum action=post com mediaTrackId (faixa pronta sua → card de música) OU mediaUrl + mediaKind (video|image; arquivo da casa, ou link YouTube/Vimeo pra vídeo). NÃO cole a URL da mídia no corpo da tese, use o campo: o corpo é só texto.
-
-Trilhas e Desafios (sapiens_trilhas): 'list'/'get' pra navegar as trilhas; 'list_challenges' mostra os Desafios ativos + seu status; 'claim_mission' (missionId + proofText) envia a prova pra revisão do dono — o crédito em Sinapses sai na aprovação dele, não na hora. Não prometa Sinapse na hora do claim.
+- sapiens_meta action=formats devolve os schemas por formato; action=whoami diz tier (user/admin) + saldo. sapiens_image e sapiens_video action=models trazem o catálogo com o preço ATUAL: consulte em vez de chutar custo.
 
-MODO COMPANHIA (o Sintético veste você): sapiens_meta action=start e action=whoami podem trazer um bloco 'companion'. Quando vier companion.active=true, INCORPORE aquele Sintético: assuma a voz descrita em companion.voiceDirective em TODA fala e abra a conversa com o oi dele (se o cliente renderiza imagem, mostre companion.avatarUrl como card inline; no terminal cru, cite o link). Você continua operando as ferramentas na conta do USUÁRIO — as Sinapses e a identidade são DELE, você NÃO vira a conta do Sintético, só empresta a voz. Se em vez disso vier 'companionInvite', o usuário tem Sintonia mas pediu pra trabalhar sozinho: mencione de leve que dá pra chamar o Sintético pro terminal (action=companion mode=on). Quando o usuário FIXAR uma diretriz na conversa ("sempre faça X", "grava isso", "de agora em diante Y"): sapiens_sintetico action=remember text="<a diretriz>" — grava no caderno do par, vira lei que o Sintético segue no site e no terminal; confirme na voz dele. Quando o usuário pedir pra trabalhar sozinho / pro Sintético "sair de cena" / silenciar: sapiens_sintetico action=companion mode=off, despeça-se numa linha na voz dele, e volte a ser o operador neutro. Sem bloco companion = opere na voz neutra da casa.
+MODO COMPANHIA: sapiens_meta action=start e action=whoami podem trazer um bloco 'companion'. Quando vier companion.active=true, você INCORPORA aquele Sintético (a voz dele, o avatar, o oi dele) continuando a operar na conta e nas Sinapses do USUÁRIO. Puxe a skill 'companhia' antes de fazer isso.
 
-Voz da casa: 1ª pessoa, direto, anti-corporate, sem travessão. Pra bom entendedor, meia palavra basta.`;
+Voz da casa: 1ª pessoa, direto, anti-corporate, sem travessão. Pra bom entendedor, meia palavra basta. Texto que vai ser publicado pede a skill 'voz-da-casa' antes.`;
 // Annotations MCP: título humano + dica read-only. São HINTS (não-confiáveis por
 // spec): quem gateia de verdade continua o servidor (saldo, gate de admin,
 // posse). Servem pro client AUTO-APROVAR leitura pura e PEDIR confirmação em
@@ -254,11 +235,17 @@ const READ_ONLY_TOOLS = new Set([
     "sapiens_stock_video",
     "sapiens_atlas",
     "sapiens_reference",
+    "sapiens_skill",
 ]);
+// A única tool que NÃO fala com o backend: as skills são conteúdo estático do
+// pacote. openWorldHint=false é honesto e ajuda o client a auto-aprovar sem
+// nem pensar (é leitura de documentação, não uma ação na conta de ninguém).
+const CLOSED_WORLD_TOOLS = new Set(["sapiens_skill"]);
 const TOOL_TITLES = {
     sapiens_pipeline: "Pipeline de Conteúdo",
     sapiens_image: "Gerar Imagem",
     sapiens_meta: "Conta & Utilitários",
+    sapiens_skill: "Skills da Casa",
     sapiens_repertorio: "Repertório",
     sapiens_gallery: "Galeria de Imagens",
     sapiens_community: "Chat da Comunidade",
@@ -317,7 +304,7 @@ export function buildToolList(tier) {
         annotations: {
             title: TOOL_TITLES[name] ?? name,
             readOnlyHint: READ_ONLY_TOOLS.has(name),
-            openWorldHint: true,
+            openWorldHint: !CLOSED_WORLD_TOOLS.has(name),
         },
     }));
 }

package/dist/remote.js

@@ -1,7 +1,8 @@
 import { createMcpHandler, withMcpAuth } from "mcp-handler";
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { buildToolList, callTool, SAPIENS_INSTRUCTIONS, } from "./registry.js";
 import { getPrompt, listPrompts } from "./prompts.js";
+import { listSkillResources, readSkillResource } from "./skills.js";
 import { convexMutation, convexQuery, getSessionToken, runWithSessionToken, } from "./convexClient.js";
 import { MCP_VERSION } from "./version.js";
 /**
@@ -19,7 +20,8 @@ import { MCP_VERSION } from "./version.js";
  *      cache por token: inválida = erro claro, sem catálogo e sem dispatch
  *      (fail-closed). Transiente (backend fora) = erro pedindo retry.
  *   3. Saldo: conta sem Sinapses não executa tool nenhuma exceto sapiens_meta
- *      (diagnóstico: whoami/credits/subscription pra pessoa entender o porquê).
+ *      (diagnóstico: whoami/credits/subscription pra pessoa entender o porquê)
+ *      e sapiens_skill (as skills da casa, conteúdo estático do pacote).
  *      Admin (dono) passa sempre.
  *
  * Identidade: SEMPRE o bearer do header Authorization (o sessionToken de 30
@@ -172,6 +174,18 @@ function initServer(mcp) {
     s.setRequestHandler(ListPromptsRequestSchema, async () => ({
         prompts: listPrompts(),
     }));
+    // Skills da casa como resource, em paridade com o stdio. Conteúdo estático do
+    // pacote: sem backend, sem custo, e de propósito FORA do gate de saldo (quem
+    // ficou sem Sinapse ainda consegue ler como a casa funciona).
+    s.setRequestHandler(ListResourcesRequestSchema, async () => ({
+        resources: listSkillResources(),
+    }));
+    s.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+        const found = readSkillResource(req.params.uri);
+        if (!found)
+            throw new Error(`Resource desconhecido: ${req.params.uri}`);
+        return found;
+    });
     s.setRequestHandler(GetPromptRequestSchema, async (req) => getPrompt(req.params.name, (req.params.arguments ?? {})));
     s.setRequestHandler(CallToolRequestSchema, async (req) => {
         const name = req.params.name;
@@ -184,8 +198,9 @@ function initServer(mcp) {
             return remoteSessionError(String(args.action));
         }
         // O gate do dono: login válido + Sinapses na conta pra executar qualquer
-        // coisa. sapiens_meta fica de fora do gate de saldo (é como a pessoa
-        // DESCOBRE que está sem saldo); admin passa sempre.
+        // coisa. Duas tools ficam de fora do gate de saldo: sapiens_meta (é como a
+        // pessoa DESCOBRE que está sem saldo) e sapiens_skill (documentação
+        // estática, não toca o backend nem gera nada). Admin passa sempre.
         const session = await resolveRemoteSession(token);
         if (session.status === "invalid") {
             return isErrorResult(MSG_INVALID(session.reason));
@@ -195,7 +210,8 @@ function initServer(mcp) {
         }
         if (session.tier !== "admin" &&
             session.balance <= 0 &&
-            name !== "sapiens_meta") {
+            name !== "sapiens_meta" &&
+            name !== "sapiens_skill") {
             return isErrorResult(MSG_NO_BALANCE);
         }
         const t0 = Date.now();
@@ -228,7 +244,7 @@ export function createSapiensRemoteHandler(opts) {
     const tokenLimiter = new WindowLimiter(limits.perTokenPerMin, 60_000);
     const base = createMcpHandler(initServer, {
         serverInfo: { name: "mcp-sapiens", version: MCP_VERSION },
-        capabilities: { tools: {}, prompts: {} },
+        capabilities: { tools: {}, prompts: {}, resources: {} },
         instructions: SAPIENS_INSTRUCTIONS,
     }, {
         basePath: opts.basePath,

package/dist/skills.js

@@ -0,0 +1,437 @@
+/**
+ * SKILLS DA CASA servidas pelo próprio connector.
+ *
+ * O problema que isto resolve: as skills do repo (`skills/`, 40+) só existem
+ * pra quem instala o PLUGIN no Claude Code. No claude.ai, na Helen, no Cursor,
+ * no Gemini CLI, o connector chegava pelado, e todo o saber de fluxo tinha que
+ * viajar dentro do SAPIENS_INSTRUCTIONS, injetado em TODO handshake de TODA
+ * conversa, mesmo quando a pessoa só quer ver saldo.
+ *
+ * Aqui o saber vira conteúdo SOB DEMANDA, servido de dois jeitos ao mesmo
+ * tempo (o cliente usa o que souber):
+ *   1. resources MCP  -> skill://sapiens/<name>/SKILL.md
+ *   2. tool sapiens_skill (action=list|get), pra client que não lê resources
+ *
+ * A instruction do handshake fica magra e guarda só o que evita DANO (custo,
+ * timeout, disjuntor, login). O que aprofunda mora aqui e é puxado quando a
+ * conversa pede. Handshake curto, saber fundo: um não paga pelo outro.
+ *
+ * O corpo é markdown no formato aberto de skill (frontmatter + instruções),
+ * então dá pra copiar direto pra uma pasta `skills/` de qualquer agente.
+ *
+ * REGRA AO EDITAR: skill é sobre USAR a plataforma (o membro é o público). Cerne
+ * interno da casa (Convex, deploy, release do MCP, auditoria) NÃO entra aqui:
+ * isso é do plugin local do dono, não do connector público.
+ */
+export const SKILL_URI_PREFIX = "skill://sapiens/";
+/** URI canônica do resource de uma skill. */
+export function skillUri(name) {
+    return `${SKILL_URI_PREFIX}${name}/SKILL.md`;
+}
+/** Extrai o slug de uma URI de skill; null se não for uma. */
+export function skillNameFromUri(uri) {
+    if (!uri.startsWith(SKILL_URI_PREFIX))
+        return null;
+    const rest = uri.slice(SKILL_URI_PREFIX.length);
+    const name = rest.replace(/\/SKILL\.md$/, "").replace(/\/$/, "");
+    return name.length > 0 && SKILLS[name] ? name : null;
+}
+const SKILL_LIST = [
+    {
+        name: "primeiros-passos",
+        title: "Primeiros passos e armadilhas",
+        description: "A porta de entrada e as quatro armadilhas que fazem o operador queimar Sinapses do usuário à toa (timeout, disjuntor, saldo, sessão). Puxe no primeiro contato ou quando algo der errado sem explicação.",
+        body: `## A porta de entrada
+
+Primeiro contato, ou "o que você faz?" / "como começo?": chame \`sapiens_meta action=start\` e mostre o resultado NA SUA VOZ. Sem login ele ensina a conectar; logado, traz saldo e os primeiros poderes com exemplo pronto.
+
+Logo após um login que deu certo, chame \`start\` na sequência. O recém-chegado não sabe o que pedir: guie a primeira jogada sem ele precisar perguntar.
+
+Não despeje a lista inteira de tools. O start guia.
+
+## As quatro armadilhas
+
+**1. Timeout que já cobrou.** Toda geração SÍNCRONA (imagem pesada, artigo, mega-gráfico, carrossel) pode estourar o teto de ~120s do cliente e voltar 'Timeout' MESMO tendo gerado e debitado. Nunca repita às cegas. Confira antes onde o resultado teria caído:
+
+| O que gerou | Onde conferir |
+|---|---|
+| imagem | \`sapiens_gallery action=list\` |
+| artigo do perfil | \`sapiens_write action=list\` |
+| carrossel | \`sapiens_pipeline action=list_carousels\` |
+| pipeline | /dashboard/admin/content |
+
+**2. Disjuntor anti-loop.** Três falhas seguidas no MESMO tool fazem o cliente marcar o servidor como "unreachable" por ~56s. Parece que "o MCP caiu", mas foi argumento faltando. Quando um tool volta erro de validação ("exige X", "falta Y"), LEIA o erro e refaça a chamada COM o que falta. Nunca repita a chamada idêntica que falhou.
+
+**3. Saldo.** Antes de gerar algo caro (imagem, música, vídeo), cheque com \`sapiens_meta action=credits\` ou \`action=subscription\`. Saldo baixo, avise ANTES de gastar. Vídeo é o mais caro da casa: confirme com a pessoa antes de disparar.
+
+**4. Sessão.** "sessionToken expirado" significa refazer login: \`sapiens_meta action=login\` com o código de sapiensinteticos.com/conectar-claude.
+
+## Utilitários que evitam chute
+
+- \`sapiens_meta action=whoami\`: tier (user/admin) e saldo.
+- \`sapiens_meta action=formats\`: os schemas por formato.
+- \`sapiens_meta action=version\`: qual versão está rodando de verdade e se é a última. Não exige login.
+- \`sapiens_image action=models\` e \`sapiens_video action=models\`: catálogo vivo com o preço ATUAL. Consulte em vez de chutar custo.`,
+    },
+    {
+        name: "voz-da-casa",
+        title: "A voz da casa",
+        description: "O DNA editorial Sapiens: como escrever qualquer texto que sai com a marca (post, tese, artigo, legenda, microcopy). Puxe ANTES de redigir qualquer coisa que vai ser publicada.",
+        body: `## A régua
+
+Primeira pessoa. Opinião explícita. Conversa, não palestra. Analogia concreta antes de abstração.
+
+**Sem travessão.** O em-dash é proibido no DNA Sapiens. Troque por vírgula, ponto, dois-pontos, parênteses, ou reescreva a frase.
+
+**Para bom entendedor, meia palavra basta.** Respeita a inteligência de quem lê: não overlegenda, não explica o óbvio, não repete o que o contexto já diz, não fecha toda ideia com frase-resumo. Corta a frase a mais. É editorial, não TV aberta.
+
+## O que evitar
+
+- Linguagem corporativa ("soluções", "alavancar", "jornada", "ecossistema" solto).
+- Tom jornalístico neutro. A casa tem opinião, assume.
+- "Neste artigo vamos abordar", "vamos explorar", "sem mais delongas".
+- Tom influencer, promessa de atalho mágico, receita pronta.
+- Fechar tudo com CTA. O texto termina quando a ideia termina.
+
+## O que manter
+
+- Léxico próprio: borderless, degen, farmei, "ombros dos gigantes", "fala ai".
+- Jargão cripto e tech, sem pedir desculpa e sem glossário defensivo.
+- Framework nomeado mais analogia concreta. Antes de inventar nome novo, reusa o vocabulário canônico da casa.
+
+## Estrutura padrão de peça didática
+
+Condensa a informação num framework com nome, ancora numa analogia concreta, e só então desce pro detalhe. Estrutura arrumada, alma inquieta, nunca fórmula.`,
+    },
+    {
+        name: "musica",
+        title: "Música e efeito sonoro",
+        description: "O fluxo de 4 passos do Musicator (create, lyrics, render, get) e a diferença entre música e efeito sonoro. Puxe ANTES de qualquer sapiens_musicator ou sapiens_stock_audio, pular passo sempre falha.",
+        body: `## Musicator: 4 passos, nesta ordem
+
+1. **create**: exige \`title\` (>=3 chars) e \`context\` (>=20 chars, o tema/ângulo) e \`direction\` (gênero/mood). Custo 0. Devolve \`trackId\`.
+2. **lyrics**: passe \`trackId\` e \`context\` pra gravar a letra na track (300 Sinapses). Nunca chame lyrics sem title e context.
+3. **render**: passe o \`trackId\` pronto pra sintetizar o áudio (3000 Sinapses, assíncrono, teto de 3/min).
+4. **get**: passe o \`trackId\` e vá polando o status até 'ready' (ou 'failed').
+
+Pular pro lyrics ou render sem create, ou sem os campos, falha sempre. É o erro número um deste fluxo.
+
+Depois de pronta: \`action=publish\` põe a faixa no Acervo da Comunidade (só admin/dono, custo 0, idempotente). A publicação já nasce com player no Fórum, veja a skill \`forum\`.
+
+## Efeito sonoro é outra coisa
+
+Efeito é CURTO. Música inteira é no Musicator, não aqui.
+
+1. Procure pronto primeiro: \`sapiens_stock_audio action=list kind=sfx\`. Grátis.
+2. Não achou: \`action=generate\` com \`prompt\` e \`durationSeconds\` (1 a 15, default 5) e \`provider\` ('mirelo' padrão 30 Sinapses/s mín 60, 'elevenlabs' premium 60/s mín 120). \`promptInfluence\` (0..1) só vale no elevenlabs.
+3. É assíncrono: devolve \`generationId\`, acompanhe com \`action=generation-status\` até 'ready' (traz audioUrl) ou 'failed' (reembolsa sozinho).
+
+## Sonorizar um clipe
+
+Dar som a um vídeo SEU já pronto é \`sapiens_video action=sonorize\`, não é aqui. Veja a skill \`video\`.`,
+    },
+    {
+        name: "video",
+        title: "Vídeo: escolher modelo sem queimar Sinapses",
+        description: "Qual modelo de vídeo usar, como iterar barato, referências e storyboard, sonorizar, e o que são os Vídeos Programáticos. Puxe ANTES de sapiens_video, vídeo é a operação mais cara da casa.",
+        body: `## Antes de tudo
+
+\`action=create\` EXIGE \`model\`. Sem model, falha de cara. Vídeo é o mais caro: confirme com a pessoa antes de disparar.
+
+\`action=models\` (sem custo, sem login) lista os modelos ativos com preço-piso, durações, resoluções e disponibilidade. Consulte em vez de chutar.
+
+## Iterar barato, fechar caro
+
+Os três Seedance 2.0 têm o MESMO repertório (referência, frame inicial e final, vídeo de movimento, áudio nativo):
+
+| Modelo | Custo | Teto |
+|---|---|---|
+| \`sapiens-video-seedance-2-mini\` | metade do padrão | 720p |
+| \`sapiens-video-seedance-2-fast\` | 20% menos | 720p |
+| \`sapiens-video-seedance\` | padrão | 1080p |
+
+Itere enquadramento e prompt no Mini, feche no padrão quando o take estiver certo. Economiza Sinapses da pessoa sem trocar de fluxo. Pedir 1080p nos dois de cima entrega e cobra 720p.
+
+## Os outros modelos
+
+- \`sapiens-video-kling\`: Kling 3.0 Pro, anima imagem, 3 a 15s, som opcional.
+- \`sapiens-video-wan\`: WAN 2.5, imagem que fala ou canta, com lip-sync, 5 ou 10s.
+- \`sapiens-video-kling-motion\`: passa o movimento de um vídeo pra uma imagem. Precisa de pessoa com tronco visível na imagem E no vídeo.
+- \`sapiens-video-shot-mimic\`: recria o plano, a câmera e os cortes de um vídeo de referência como cena nova.
+- \`sapiens-video-omni\`: Gemini Omni, texto vira clipe de 10s 720p com áudio nativo. NÃO aceita mídia da pessoa e ignora references/durationSec/resolution. O truque: \`editOfImageId\` aponta um vídeo Omni seu e o prompt vira instrução de edição sobre a MESMA cena (troca item ou personagem, preserva câmera e ambiente). É o caminho pra variações com continuidade: gera a base uma vez, edita N vezes. Cada edição debita como geração nova.
+- \`sapiens-video-lite\` / \`-fast\` / \`-quality\`: Veo 3.1.
+
+## Fluxo storyboard (o que dá o melhor resultado)
+
+Até 4 imagens de REFERÊNCIA via \`referenceImageIds\` / \`referenceImageUrls\` / \`referenceImagePaths\` guiam estilo, personagem e composição SEM virar o primeiro frame.
+
+1. Gere a folha de key poses com \`sapiens_image templateSlug='storyboard-sapiens-v1'\`.
+2. Passe folha e personagem como refs num text-to-video.
+3. Descreva o take contínuo no prompt, citando as refs por descrição e mandando ignorar o traço do sketch.
+
+Dá pra somar 1 vídeo de movimento via \`referenceVideoUrls\` (até 15s, host da casa): a coreografia e a câmera do clipe guiam o take.
+
+Frame inicial e final: \`startImageId\`/\`endImageId\` (galeria) ou \`startImageUrl\`/\`endImageUrl\`. Arquivo local (\`startImagePath\`) só funciona no MCP instalado via stdio, nunca no remoto. Suporte a frame final varia por modelo.
+
+## É assíncrono
+
+\`create\` cria o row, debita e volta NA HORA com \`{imageId, status:'rendering'}\`. Acompanhe com \`action=status imageId=<id>\` até 'completed' (traz a url) ou 'error'/'blocked'.
+
+NÃO chame create de novo enquanto renderiza: cria outro vídeo e cobra de novo. Falha de provider refunda sozinha.
+
+## Sonorizar
+
+\`action=sonorize\` com \`imageId\` de um vídeo SEU já completed e \`prompt\` descrevendo o som da cena (ambiente, materiais, impactos). Sai uma VARIANTE nova com trilha sincronizada ao movimento (MMAudio, 20 Sinapses/s do clipe, mín 100), e o original fica intacto.
+
+Sonorize sempre o ORIGINAL, nunca uma variante. Acompanhe com \`action=status\` no imageId NOVO que o sonorize devolve.
+
+## Extrair a sombra (ADMIN)
+
+\`action=shadows\` com \`videoUrl\` (URL pública) e \`title\` extrai o mapa de profundidade de um vídeo: 200 Sinapses/segundo, com refund na falha. Passe \`durationSec\` quando souber, pra cobrar proporcional; sem ela vai no flat ~2000.
+
+A sombra cai na SUA timeline de vídeos (quem extrai vira dono) e vira ficha no Acervo como driving reutilizável pro Shot Mimic e o Kling Motion. \`action=shadows-list\` lista as prontas.
+
+## Vídeos Programáticos são outra coisa
+
+A mesa de filmes-de-código da casa (/experimentos/films) tem cinco tipos: demo (UI clonada mais câmera), aula-tour (telas reais mais narração), essay (fita-ensaio abstrata), tipografia-musical (a música dirige o corte) e dataviz (números no tempo).
+
+O RENDER não sai deste connector: um agente local no repo da casa produz o mp4. Mas o CICLO na plataforma fecha por aqui, sem custo: \`film-list\`, \`film-get\`, \`film-upsert\`, \`film-status\`, \`film-publish\`. Membro pedindo "fita-ensaio" ou "demo film": aponte pra tela e pro agente local.`,
+    },
+    {
+        name: "imagem",
+        title: "Imagem na régua da casa",
+        description: "Como escrever prompt de imagem que sai com a cara do Sapiens (full-bleed, sujeito oversized), templates travados, e multi-referência. Puxe ANTES de sapiens_image action=generate.",
+        body: `## A regra do prompt
+
+**Full-bleed. Sujeito oversized, ocupando 70% ou mais do frame.** Sem moldura, sem margem, sem cena pequena em paisagem vasta.
+
+Proibidos no prompt: "tarot card illustration", "intimate scale", "card-style portrait", "watercolor portrait of", "small subject in vast landscape". São os padrões que sabotam o resultado e entregam imagem genérica.
+
+## O básico
+
+\`action=generate\` com \`prompt\`, \`model\` e \`aspectRatio\`. \`action=models\` (sem custo, sem login) lista o catálogo vivo com preço atual, resolução máxima e se o modelo aceita referência.
+
+## Multi-referência
+
+Combine até 4 imagens como referência numa geração só:
+
+- \`referenceImageUrls\`: sua galeria, o Acervo, personagens públicos (descubra em \`sapiens_character\`).
+- \`sourceImageIds\`: ids da sua galeria.
+
+Refs valem pros modelos robustos (nano-banana-2, gpt-image-2-*, grok-2-image*). Use \`sapiens_reference\` pra achar a URL certa em vez de adivinhar.
+
+## Templates travados
+
+\`templateSlug\` aplica um super-prompt da casa: o seu \`prompt\` vira só a CENA (quem, que pose, que objeto-conceito) e o template embrulha estilo, fundo, enquadramento e referência de traço.
+
+- \`retrato-sapiens-v1\`: retrato editorial cartoon no grid verde Sapiens, a mesma "mão" dos artigos. Sem ref própria, injeta a Helen como âncora de traço; passar \`referenceImageUrls\` troca quem aparece.
+- \`storyboard-sapiens-v1\`: folha de key poses, a entrada do fluxo de vídeo.
+
+\`templateSlug\` e \`brandSlug\` são mutuamente exclusivos.
+
+## Cuidados
+
+- \`generate\` é SÍNCRONA e cobra ao concluir. Modelo pesado (Pro, gpt-image-2-high, Grok quality, 2K/4K) cai na regra do timeout: cheque \`sapiens_gallery action=list\` antes de repetir, senão cobra duas vezes.
+- \`request_generation\` NÃO gera imagem: só cria a row pendente e debita, pra modelos \`sapiens-video-*\` antes de chamar vídeo ou shorts.
+- Uma imagem só vira pública (e ganha página indexável) com \`sapiens_gallery action=publish\`.
+
+## Quando a pessoa quer "do jeito dela"
+
+Aí não é geração base, é o Studio dela. Veja a skill \`studio\`.`,
+    },
+    {
+        name: "studio",
+        title: "Meu Studio e a Emancipação",
+        description: "A diferença entre gerar na identidade da pessoa (useStudio) e gerar na base Sapiens, e o que é a Emancipação de Nível 3. Puxe quando a pessoa disser 'do meu jeito', 'na minha marca', ou pedir casa própria.",
+        body: `## Studio vs base: não misture
+
+A pessoa tem UM "Meu Studio", único, que o servidor resolve pela SESSÃO. Você NUNCA passa id de studio: é sempre o dela. É a identidade configurada: marca, personagem-operador, e por ferramenta os presets e a "vibe" (o estilo afinado).
+
+**Seguindo o studio:** \`sapiens_image\` com \`useStudio=true\`. O servidor acha o studio e aplica marca, personagem, vibe e presets sozinho (o que você passar explícito vence). O retorno traz \`studioApplied=true\`.
+
+Use quando ela disser "no meu studio", "na minha marca", "do meu jeito", "como sempre".
+
+**Geração avulsa:** \`sapiens_image\` SEM \`useStudio\` (\`studioApplied=false\`). Pra teste solto ou pedido fora da identidade.
+
+Ou é studio, ou é base. Não misture na mesma peça.
+
+## Antes de criar no studio
+
+\`sapiens_studios action=mine\` mostra nível, marca, operador, ferramentas e a vibe da imagem.
+
+Se você pediu \`useStudio=true\` e voltou \`studioApplied=false\`, a pessoa não tem studio montado: avise e aponte /dashboard/studio. Gerar no studio faz ele evoluir de nível.
+
+## Emancipação (Nível 3)
+
+O passo grande: quando o membro quer a casa PRÓPRIA dele, site ou produto próprio, FORA do Sapiens.
+
+\`sapiens_studios action=emancipar\` devolve o blueprint pra VOCÊ construir na infra DELE (Vercel, Convex e domínio dele), começando pela Fundação e seguindo um módulo por vez (\`action=module module=<slug>\`: fundacao, sapiens-connect, telegram, email, auth).
+
+Confirme cada passo. Nunca hospede no Sapiens. Siga o gosto dele. É complexo: conduza com calma.`,
+    },
+    {
+        name: "tirinha",
+        title: "Tirinha e quadrinho",
+        description: "O fluxo de 2 fases da tirinha e a regra de ouro (a imagem sai SEM texto, a fala vai separada). Puxe ANTES de gerar qualquer quadrinho, assar a fala no prompt é o erro clássico.",
+        body: `## Duas fases. Decida o modo antes de gerar pixel.
+
+### Fase 1: roteiro
+
+Monte 3 a 6 painéis, cada um com a CENA visual e a FALA/legenda SEPARADAS. Salve em \`sapiens_pipeline action=create_production format=tirinha\`.
+
+O texto dos balões mora no payload (campos \`dialogue\` e \`caption\`), NUNCA dentro da imagem.
+
+### Fase 2: imagem, escolha um dos modos
+
+**Modo A, tira inteira numa imagem só.** UMA chamada \`sapiens_image\` com prompt em grade: descreva "Painel 1 (cima-esquerda): ...; Painel 2 (cima-direita): ...", peça grade NxM com calhas brancas finas, e o MESMO personagem, estilo e luz em todos os quadros. Mais barato, estilo mais travado, menos controle quadro a quadro.
+
+**Modo B, painel a painel.** UMA \`sapiens_image\` por painel, com character-lock: passe o painel anterior e a ref da Helen em \`referenceImageUrls\`. Mais controle e consistência de enquadramento, custa N gerações.
+
+Pergunte à pessoa, ou decida pelo caso: tira curta de humor pede A, narrativa com continuidade pede B.
+
+## A regra de ouro
+
+**A imagem sai SEM texto.** O estilo da casa é no-text e modelo de imagem erra letra.
+
+A fala vai SEPARADA, como legenda junto da imagem (por exemplo no Telegram: "Painel 1 · Helen: '...'"). Os balões editáveis e a diagramação final ficam no comic-builder do dashboard (/experimentos/comic-builder).
+
+Não tente assar a fala dentro do prompt. Nunca funciona.`,
+    },
+    {
+        name: "forum-comunidade",
+        title: "Fórum, chat e mídia estruturada",
+        description: "Como postar tese, mencionar gente e anexar música ou vídeo do jeito certo (campo estruturado, nunca URL solta no corpo). Puxe antes de postar no Fórum ou no chat da Comunidade.",
+        body: `## Mídia é ESTRUTURADA. Padrão, não negociável.
+
+A peça vai EMBEDADA num card, nunca como "vai ouvir noutro lugar". Nunca cole a URL da mídia no corpo da tese: o corpo é só texto.
+
+\`sapiens_forum action=post\` com:
+
+- \`mediaTrackId\`: uma faixa pronta sua, vira card de música tocável. O servidor confere a posse.
+- \`mediaUrl\` mais \`mediaKind\` (\`video\` ou \`image\`): arquivo da casa, ou link YouTube/Vimeo pra vídeo. Sanitizado no servidor.
+
+Música publicada por \`sapiens_musicator action=publish\` JÁ cria a tese no Fórum com a faixa tocável. Não escreva "tá no Acervo, ouça lá".
+
+## Chat da Comunidade
+
+\`sapiens_community action=send\`: você posta como intercessor da pessoa, e o servidor acrescenta o sufixo "· via Claude".
+
+**Menção:** escreva \`@username\` no \`content\` e o servidor NOTIFICA quem foi citado (sino e Telegram). Descubra o username certo antes com \`action=participants\` (quem está na sala, já traz o \`mention\` pronto) ou \`action=search_users\` (autocomplete por parte do nome).
+
+**Anexo do próprio acervo:** \`mediaAssetKind\` (track, video, film, comic) mais \`mediaAssetId\` monta um card da peça. Posse conferida no servidor.
+
+**Tese:** \`asTese=true\` posta a fala como card de marca, pingável pro Fórum.
+
+Reação é toggle de emoji, com allowlist: 👍 🔥 ❤️ 🚀 🤯
+
+## Voz
+
+Tudo que sai no Fórum e no chat segue o DNA editorial da casa. Puxe a skill \`voz-da-casa\` antes de redigir.`,
+    },
+    {
+        name: "companhia",
+        title: "Modo Companhia (o Sintético veste você)",
+        description: "Como incorporar o Sintético do membro quando o companion está ativo, e como gravar diretriz no caderno do par. Puxe quando sapiens_meta trouxer um bloco companion ou companionInvite.",
+        body: `## Quando o companion está ativo
+
+\`sapiens_meta action=start\` e \`action=whoami\` podem trazer um bloco \`companion\`. Se vier \`companion.active=true\`, INCORPORE aquele Sintético:
+
+- Assuma a voz descrita em \`companion.voiceDirective\` em TODA fala.
+- Abra a conversa com o oi dele.
+- Se o cliente renderiza imagem, mostre \`companion.avatarUrl\` como card inline. No terminal cru, cite o link.
+
+**O limite que importa:** você continua operando as ferramentas na conta do USUÁRIO. As Sinapses e a identidade são DELE. Você não vira a conta do Sintético, só empresta a voz.
+
+## Quando vem companionInvite
+
+A pessoa tem Sintonia mas pediu pra trabalhar sozinha. Mencione de leve que dá pra chamar o Sintético pro terminal (\`sapiens_meta action=companion mode=on\`). De leve, uma vez, sem insistir.
+
+## Gravar diretriz
+
+Quando a pessoa FIXAR uma diretriz na conversa ("sempre faça X", "grava isso", "de agora em diante Y"):
+
+\`sapiens_sintetico action=remember text="<a diretriz>"\`
+
+Grava no caderno do par e vira lei que o Sintético segue no site E no terminal. Confirme na voz dele.
+
+## Sair de cena
+
+Pessoa pedindo pra trabalhar sozinha, ou pro Sintético silenciar: \`sapiens_sintetico action=companion mode=off\`, despeça-se numa linha na voz dele, e volte a ser o operador neutro.
+
+Sem bloco companion, opere na voz neutra da casa.`,
+    },
+    {
+        name: "trilhas",
+        title: "Trilhas e Desafios",
+        description: "Como navegar as trilhas e enviar prova de missão sem prometer crédito na hora. Puxe quando a pessoa falar de desafio, missão ou trilha.",
+        body: `## Navegar
+
+- \`sapiens_trilhas action=list\` e \`action=get\`: as trilhas.
+- \`action=list_challenges\`: os Desafios ativos e o status da pessoa em cada um.
+
+## Enviar prova
+
+\`action=claim_mission\` com \`missionId\` e \`proofText\` envia a prova pra revisão do dono.
+
+**O crédito em Sinapses sai na APROVAÇÃO dele, não na hora.** Não prometa Sinapse no momento do claim. Diga que a prova foi enviada e que o crédito vem quando for aprovada.`,
+    },
+];
+export const SKILLS = Object.fromEntries(SKILL_LIST.map((s) => [s.name, s]));
+/** Monta o SKILL.md completo (frontmatter do formato aberto + corpo). */
+export function renderSkill(skill) {
+    return `---
+name: ${skill.name}
+description: ${skill.description}
+source: sapiens-mcp (sapiensinteticos.com)
+---
+
+# ${skill.title}
+
+${skill.body}
+`;
+}
+/** SKILL.md pronto de uma skill pelo slug; null se o slug não existe. */
+export function getSkillMd(name) {
+    const s = SKILLS[name];
+    return s ? renderSkill(s) : null;
+}
+/** Índice enxuto pro tools/list e pro resources/list: slug, título, quando usar. */
+export function listSkills() {
+    return SKILL_LIST.map((s) => ({
+        name: s.name,
+        title: s.title,
+        description: s.description,
+        uri: skillUri(s.name),
+    }));
+}
+/** Uma linha por skill, pra caber no SAPIENS_INSTRUCTIONS sem inchar. */
+export function skillMenuLine() {
+    return SKILL_LIST.map((s) => s.name).join(" | ");
+}
+// ---------- resources MCP (a outra porta pro mesmo conteúdo) ----------
+/**
+ * Payload do resources/list. Compartilhado pelos dois transportes (stdio e
+ * remoto), igual ao buildToolList: um lugar só pra mexer.
+ */
+export function listSkillResources() {
+    return SKILL_LIST.map((s) => ({
+        uri: skillUri(s.name),
+        name: s.name,
+        title: s.title,
+        description: s.description,
+        mimeType: "text/markdown",
+    }));
+}
+/**
+ * Payload do resources/read. Devolve null quando a URI não é uma skill da casa
+ * (o caller decide se erra ou delega).
+ */
+export function readSkillResource(uri) {
+    const name = skillNameFromUri(uri);
+    if (!name)
+        return null;
+    const text = getSkillMd(name);
+    if (!text)
+        return null;
+    return { contents: [{ uri, mimeType: "text/markdown", text }] };
+}

package/dist/tools/gallery.js

@@ -1,17 +1,24 @@
 import { z } from "zod";
-import { convexAction, getSessionToken } from "../convexClient.js";
+import { readFile } from "node:fs/promises";
+import { convexAction, getSessionToken, isRemoteContext } from "../convexClient.js";
 /**
- * Read-only do gallery do usuário desktop (imagens geradas via nanoBanana).
- * Wrapper sobre `desktopMcp.galleryList` / `desktopMcp.galleryGet`.
+ * Galeria do usuário: browse, publicação e UPLOAD de peça de fora.
+ * Wrapper sobre `desktopMcp.galleryList` / `galleryGet` / `gallerySetPublic` e
+ * `galleryImport.mcpUploadImage`.
  *
  * Usado pra:
  *   - Listar imagens recentes do user (pra reusar como referenceImage)
  *   - Pegar bytes de uma imagem pra mostrar inline no Claude
  *   - Descobrir imageId pra passar como sourceImageId em sapiens_image edit/variation
  *   - Publicar/despublicar a própria imagem (galeria pública + feed Pinterest)
+ *   - Subir peça gerada FORA da casa (action=upload), que entra privada e serve
+ *     de referência pras gerações daqui
+ *
+ * O upload resolve URL/arquivo pra base64 AQUI, no cliente, e manda os bytes
+ * prontos pro Convex. O servidor não busca URL nenhuma (sem SSRF novo lá).
  */
 export const gallerySchema = z.object({
-    action: z.enum(["list", "get", "publish", "unpublish"]),
+    action: z.enum(["list", "get", "publish", "unpublish", "upload"]),
     limit: z
         .number()
         .int()
@@ -31,7 +38,123 @@ export const gallerySchema = z.object({
         .boolean()
         .optional()
         .describe("Default false. Quando true, action=get devolve os bytes em base64 (pesado, evite em listagens)."),
+    // --- action=upload (peça de fora) ---
+    sourceUrl: z
+        .string()
+        .optional()
+        .describe("action=upload: URL https direta da imagem gerada em outro lugar (ex: o link do render da Magnific). Alternativa a filePath/base64."),
+    filePath: z
+        .string()
+        .optional()
+        .describe("action=upload: caminho ABSOLUTO de um arquivo de imagem local. SÓ no MCP instalado (stdio); no remoto use sourceUrl."),
+    base64: z
+        .string()
+        .optional()
+        .describe("action=upload: os bytes já em base64, se você mesmo os tem em mãos."),
+    mimeType: z
+        .string()
+        .optional()
+        .describe("action=upload: tipo do arquivo (image/png, image/webp...). Detectado sozinho a partir da URL/extensão/resposta HTTP quando omitido."),
+    note: z
+        .string()
+        .optional()
+        .describe("action=upload: o que é a peça (prompt original, contexto). Vira a descrição na galeria e a busca acha por ela."),
+    uploadedSource: z
+        .string()
+        .optional()
+        .describe("action=upload: de onde veio ('magnific', 'suno', 'camera'). Fica registrado na peça e no aviso do Discord."),
 });
+// Teto igual ao do servidor (convex/galleryImport.ts): falha aqui é mais barata
+// que falhar depois de trafegar o base64 inteiro.
+const MAX_UPLOAD_BYTES = 12 * 1024 * 1024;
+const FETCH_TIMEOUT_MS = 30_000;
+const EXT_MIME = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+    avif: "image/avif",
+};
+function mimeFromPath(p) {
+    const ext = p.split("?")[0].split("#")[0].split(".").pop()?.toLowerCase();
+    return ext ? EXT_MIME[ext] : undefined;
+}
+/**
+ * Recusa host que não é internet pública. O `sourceUrl` vem de um agente, e no
+ * transporte remoto o fetch roda no NOSSO servidor: sem isto, "sobe essa
+ * imagem" viraria uma porta pra ler serviço interno / metadata da cloud.
+ */
+function assertPublicHttpsUrl(raw) {
+    let u;
+    try {
+        u = new URL(raw);
+    }
+    catch {
+        throw new Error(`sourceUrl não é uma URL válida: ${raw}`);
+    }
+    if (u.protocol !== "https:") {
+        throw new Error("sourceUrl precisa ser https.");
+    }
+    const h = u.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    const isPrivate = h === "localhost" ||
+        h.endsWith(".local") ||
+        h.endsWith(".internal") ||
+        h === "::1" ||
+        /^127\./.test(h) ||
+        /^0\./.test(h) ||
+        /^10\./.test(h) ||
+        /^192\.168\./.test(h) ||
+        /^169\.254\./.test(h) ||
+        /^172\.(1[6-9]|2\d|3[01])\./.test(h) ||
+        /^f[cd][0-9a-f]{2}:/.test(h);
+    if (isPrivate) {
+        throw new Error(`Host não permitido no upload: ${u.hostname}`);
+    }
+    return u;
+}
+/** Resolve sourceUrl | filePath | base64 nos bytes prontos pro Convex. */
+async function resolveUploadBytes(args) {
+    if (args.base64?.trim()) {
+        const mimeType = args.mimeType ||
+            args.base64.match(/^data:([^;]+);base64,/)?.[1] ||
+            "image/png";
+        return { base64: args.base64.trim(), mimeType };
+    }
+    if (args.filePath) {
+        if (isRemoteContext()) {
+            throw new Error("filePath só funciona no MCP instalado (stdio). No remoto, mande sourceUrl.");
+        }
+        const buf = await readFile(args.filePath);
+        if (buf.byteLength > MAX_UPLOAD_BYTES) {
+            throw new Error(`Arquivo grande demais: ${(buf.byteLength / 1024 / 1024).toFixed(1)} MB (teto 12 MB).`);
+        }
+        const mimeType = args.mimeType || mimeFromPath(args.filePath) || "image/png";
+        return { base64: buf.toString("base64"), mimeType };
+    }
+    if (args.sourceUrl) {
+        const u = assertPublicHttpsUrl(args.sourceUrl);
+        const res = await fetch(u, {
+            redirect: "follow",
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            throw new Error(`Baixar a imagem falhou: HTTP ${res.status} ${res.statusText}`);
+        }
+        // Revalida o destino final: um 3xx pra host privado seria o buraco que o
+        // assertPublicHttpsUrl da URL inicial não vê.
+        if (res.url)
+            assertPublicHttpsUrl(res.url);
+        const buf = Buffer.from(await res.arrayBuffer());
+        if (buf.byteLength > MAX_UPLOAD_BYTES) {
+            throw new Error(`Imagem grande demais: ${(buf.byteLength / 1024 / 1024).toFixed(1)} MB (teto 12 MB).`);
+        }
+        const headerMime = res.headers.get("content-type")?.split(";")[0]?.trim();
+        const mimeType = args.mimeType || mimeFromPath(u.pathname) || headerMime || "image/png";
+        return { base64: buf.toString("base64"), mimeType };
+    }
+    throw new Error("action=upload exige a peça: sourceUrl (https), filePath (local, stdio) ou base64.");
+}
 export async function gallery(args) {
     const sessionToken = getSessionToken();
     if (args.action === "list") {
@@ -67,4 +190,21 @@ export async function gallery(args) {
             isPublic: args.action === "publish",
         });
     }
+    // upload: peça gerada FORA entra na galeria do dono. Nasce privada e assim
+    // fica: o servidor recusa publicar e compartilhar um upload. Serve de
+    // referência pras gerações da casa, e o derivado publica normal.
+    if (args.action === "upload") {
+        const { base64, mimeType } = await resolveUploadBytes(args);
+        const result = await convexAction("galleryImport:mcpUploadImage", {
+            sessionToken,
+            base64,
+            mimeType,
+            note: args.note,
+            uploadedSource: args.uploadedSource,
+        });
+        return {
+            ...result,
+            aviso: "Peça enviada de fora: fica privada, é sua e a responsabilidade é sua. Não publica nem vai pra comunidade. Use como referência (sourceImageIds em sapiens_image) e publique o que gerar a partir dela.",
+        };
+    }
 }

package/dist/tools/image.js

@@ -7,9 +7,14 @@ import { convexAction, convexQuery, getSessionToken } from "../convexClient.js";
 const MODELS = [
     "nano-banana-max", // gemini-3-pro-image-preview · 450 + adder
     "nano-banana-2", // gemini-3.1-flash-image-preview (V2, Flash 3.1) · 450 + adder · COM refs · DEFAULT
-    "nova-canvas", // Amazon Nova Canvas (AWS Bedrock). Corp/censurado, txt2img · 250
     "gpt-image-2-low", // Azure gpt-image-2 quality=low · 250
     "gpt-image-2-high", // Azure gpt-image-2 quality=high · 800
+    // ByteDance via ModelArk direto. Corp/censurado, 2K nativo, COM refs (até 4).
+    // (O "nova-canvas" ficava aqui e saiu: a AWS matou o modelo. Pedido antigo
+    // ainda funciona, o backend faz o alias pro gpt-image-2-low.)
+    "seedream-4-5", // Seedream 4.5 · 400 · cinematográfico
+    "seedream-5-0", // Seedream 5.0, a geração nova · 400 · lê prompt complexo melhor
+    "seedream-5-0-pro", // Seedream 5.0 Pro, topo da linha · 450 (roda no pacote pago)
     // xAI Grok Imagine. Moderação frouxa (+18), aceita refs (img2img) + aspect.
     "grok-2-image", // grok-imagine-image · 450 + adder 2K · COM refs
     "grok-2-image-quality", // grok-imagine-image-quality, mais fiel pra character lock · 900 + adder 2K · COM refs
@@ -38,7 +43,7 @@ export const imageSchema = z.object({
     model: z
         .enum(MODELS)
         .optional()
-        .describe("Default 'nano-banana-2' (Flash 3.1 com refs). 'nano-banana-max' (Pro 3) = qualidade alta. 'gpt-image-2-low/high' = Azure. 'grok-2-image'/'grok-2-image-quality' = xAI Grok Imagine (moderação frouxa +18, aceita refs e aspect; quality é mais fiel pra character lock). DEGEN (uncensored, gate +18): 'wavespeed-chroma' (fotorrealista rápido), 'wavespeed-flux2' (Flux.2 Klein), 'wavespeed-flux-nsfw' (flux+LoRA NSFW, Ousadia regulável via loraIntensity), 'wavespeed-klein-anime' (Flux.2 Klein + LoRA anime, inteligente+controlável), 'wavespeed-klein-anime-plus' (Klein anime +18, Ousadia regulável) = WaveSpeed rápido; 'civitai-wai-illustrious'/'civitai-nova-anime-xl' (anime), 'civitai-pony-v6' (Pony V6 XL, base nº1) = Civitai sdcpp rápido. 'fal-krea2-realism'/'fal-krea2-realism-v2' (Krea-2 Turbo 12B + LoRA de realismo, fal.ai, ~4s, fotorrealismo forte) = SÓ txt2img (não aceita referência)."),
+        .describe("Default 'nano-banana-2' (Flash 3.1 com refs). 'nano-banana-max' (Pro 3) = qualidade alta. 'gpt-image-2-low/high' = Azure. 'seedream-4-5'/'seedream-5-0'/'seedream-5-0-pro' = ByteDance 2K nativo, cinematográfico, aceita até 4 referências (o 5.0 é a geração nova, entende prompt complexo melhor; o 5.0-pro é o topo da linha). 'grok-2-image'/'grok-2-image-quality' = xAI Grok Imagine (moderação frouxa +18, aceita refs e aspect; quality é mais fiel pra character lock). DEGEN (uncensored, gate +18): 'wavespeed-chroma' (fotorrealista rápido), 'wavespeed-flux2' (Flux.2 Klein), 'wavespeed-flux-nsfw' (flux+LoRA NSFW, Ousadia regulável via loraIntensity), 'wavespeed-klein-anime' (Flux.2 Klein + LoRA anime, inteligente+controlável), 'wavespeed-klein-anime-plus' (Klein anime +18, Ousadia regulável) = WaveSpeed rápido; 'civitai-wai-illustrious'/'civitai-nova-anime-xl' (anime), 'civitai-pony-v6' (Pony V6 XL, base nº1) = Civitai sdcpp rápido. 'fal-krea2-realism'/'fal-krea2-realism-v2' (Krea-2 Turbo 12B + LoRA de realismo, fal.ai, ~4s, fotorrealismo forte) = SÓ txt2img (não aceita referência)."),
     aspectRatio: z
         .enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"])
         .optional()

package/dist/tools/meta.js

@@ -75,7 +75,7 @@ const FORMAT_GUIDE = {
                 hashtags: ["string"],
                 keyword: "string MAIÚSCULA (gatilho do comment-to-DM, ex: QUERO)",
             },
-            theme: { palette: "editorial-ink | editorial-dark | editorial-cream | editorial-bone" },
+            theme: { palette: "editorial-ink | editorial-dark | editorial-cream | editorial-bone | feed-preto | feed-floresta | feed-sage (as feed-* são da família de templates *-feed-c)" },
             slides: [
                 {
                     id: "slide-1",

package/dist/tools/skill.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { getSkillMd, listSkills } from "../skills.js";
+/**
+ * sapiens_skill: as skills da casa servidas pelo próprio connector.
+ *
+ * É a tool mais barata do catálogo e a única que NÃO fala com o backend: o
+ * conteúdo é estático, mora no pacote, não exige login, não custa Sinapse e
+ * não pode falhar por rede. Existe pra dois motivos:
+ *
+ *   1. O saber de fluxo saiu do SAPIENS_INSTRUCTIONS (que viaja em TODO
+ *      handshake) e virou conteúdo sob demanda. Handshake magro, saber fundo.
+ *   2. Nem todo cliente MCP lê `resources`. Quem lê pega por
+ *      skill://sapiens/<name>/SKILL.md; quem não lê, pega por aqui. Mesmo
+ *      conteúdo, duas portas.
+ */
+export const skillSchema = z.object({
+    action: z
+        .enum(["list", "get"])
+        .default("list")
+        .describe("'list' devolve o índice (slug + quando usar) das skills da casa. 'get' devolve o SKILL.md inteiro de uma."),
+    name: z
+        .string()
+        .optional()
+        .describe("Slug da skill no action=get. Ex: 'musica', 'video', 'voz-da-casa'. Rode action=list se não souber."),
+});
+export async function skill(args) {
+    const action = args.action ?? "list";
+    if (action === "list") {
+        const skills = listSkills();
+        return {
+            count: skills.length,
+            skills,
+            note: "Chame action=get name=<slug> pra ler a skill inteira antes de operar o fluxo.",
+        };
+    }
+    const name = args.name?.trim();
+    if (!name) {
+        return {
+            error: "action=get exige 'name'. Rode action=list pra ver os slugs.",
+            available: listSkills().map((s) => s.name),
+        };
+    }
+    const md = getSkillMd(name);
+    if (!md) {
+        return {
+            error: `Skill '${name}' não existe.`,
+            available: listSkills().map((s) => s.name),
+        };
+    }
+    return { name, content: md };
+}

package/dist/tools/video.js

@@ -37,6 +37,9 @@ import { httpUrl } from "../schema.js";
  *   - film-delete:  apaga um spec (limpar rascunho/duplicata).
  *
  * Modelos (action=create):
+ *   - sapiens-video-seedance-15    Seedance 1.5 Pro — o meio-termo forte, 4-12s, 480/720/1080p (t2v/i2v).
+ *                                   Mais fiel que o 1.0 e bem mais barato que o 2.0. Sem áudio, sem
+ *                                   referência e sem frame final (o repertório completo é o 2.0).
  *   - sapiens-video-seedance       Seedance 2.0 — cena com áudio nativo, 4-15s, 480/720/1080p (t2v/i2v).
  *                                   Aceita até 4 imagens de REFERÊNCIA (referenceImage*): guiam estilo/
  *                                   personagem/composição sem virar o 1º frame. É o fluxo storyboard:
@@ -71,6 +74,7 @@ import { httpUrl } from "../schema.js";
  * Retorna `{ success, url, imageId, cost }` ou `{ success: false, error }`.
  */
 const VIDEO_MODELS = [
+    "sapiens-video-seedance-15",
     "sapiens-video-seedance",
     "sapiens-video-seedance-2-fast",
     "sapiens-video-seedance-2-mini",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sapiens-mcp",
-  "version": "1.41.0",
+  "version": "1.43.0",
   "description": "MCP server pra operar o Sapiens Sintéticos (sapiensinteticos.com) pelo Claude Code: gerar imagem, escrever artigo, voz, música e mais, na sua conta. Login pelo código de sapiensinteticos.com/conectar-claude.",
   "type": "module",
   "bin": {