primocode 10.16.0 → 10.17.1

package/lib/estudio/visao/visao.swift

@@ -0,0 +1,97 @@
+// visao.swift — o Vision do macOS para o motion do PrimoCode (sem MediaPipe, sem instalar nada).
+//
+//   visao recortar <entrada> <saida.png>   recorte da pessoa (VNGeneratePersonSegmentationRequest, .accurate) → PNG com alfa
+//   visao ler <quadro.png> [...]           texto (VNRecognizeTextRequest) e rostos (VNDetectFaceRectanglesRequest) de cada quadro
+//
+// Saída: UMA linha de JSON no stdout. Caixas em pixels, origem no canto de CIMA à esquerda: [x0, y0, x1, y1].
+// O lib/estudio/visao.js compila isto uma vez (swiftc) em ~/.primocode/bin e chama sob demanda.
+import Foundation
+import Vision
+import CoreImage
+import ImageIO
+import UniformTypeIdentifiers
+
+func sair(_ o: [String: Any]) -> Never {
+    let d = (try? JSONSerialization.data(withJSONObject: o, options: [])) ?? Data("{\"ok\":false}".utf8)
+    FileHandle.standardOutput.write(d)
+    FileHandle.standardOutput.write(Data("\n".utf8))
+    exit(0)
+}
+
+func carregar(_ caminho: String) -> CGImage? {
+    guard let src = CGImageSourceCreateWithURL(URL(fileURLWithPath: caminho) as CFURL, nil) else { return nil }
+    let opc: [CFString: Any] = [kCGImageSourceCreateThumbnailFromImageAlways: true, kCGImageSourceCreateThumbnailWithTransform: true, kCGImageSourceThumbnailMaxPixelSize: 4096]
+    return CGImageSourceCreateThumbnailAtIndex(src, 0, opc as CFDictionary) ?? CGImageSourceCreateImageAtIndex(src, 0, nil)
+}
+
+func caixa(_ r: CGRect, _ w: Int, _ h: Int) -> [Double] {
+    // o Vision usa coordenadas normalizadas com a origem EMBAIXO
+    let W = Double(w), H = Double(h)
+    return [Double(r.minX) * W, (1 - Double(r.maxY)) * H, Double(r.maxX) * W, (1 - Double(r.minY)) * H].map { ($0 * 10).rounded() / 10 }
+}
+
+func recortar(_ entrada: String, _ saida: String) -> Never {
+    guard let img = carregar(entrada) else { sair(["ok": false, "error": "não abri a foto"]) }
+    let req = VNGeneratePersonSegmentationRequest()
+    req.qualityLevel = .accurate
+    req.outputPixelFormat = kCVPixelFormatType_OneComponent8
+    let h = VNImageRequestHandler(cgImage: img, options: [:])
+    do { try h.perform([req]) } catch { sair(["ok": false, "error": "o Vision falhou: \(error.localizedDescription)"]) }
+    guard let masc = req.results?.first?.pixelBuffer else { sair(["ok": false, "semPessoa": true, "error": "sem pessoa"]) }
+    // quanto da foto é pessoa (sem pessoa → o recorte não serve)
+    CVPixelBufferLockBaseAddress(masc, .readOnly)
+    let mw = CVPixelBufferGetWidth(masc), mh = CVPixelBufferGetHeight(masc), linha = CVPixelBufferGetBytesPerRow(masc)
+    var soma = 0
+    if let base = CVPixelBufferGetBaseAddress(masc) {
+        let p = base.assumingMemoryBound(to: UInt8.self)
+        for y in 0..<mh { for x in 0..<mw where p[y * linha + x] > 127 { soma += 1 } }
+    }
+    CVPixelBufferUnlockBaseAddress(masc, .readOnly)
+    let cobertura = Double(soma) / Double(max(1, mw * mh))
+    if cobertura < 0.02 { sair(["ok": false, "semPessoa": true, "cobertura": cobertura, "error": "sem pessoa na foto"]) }
+    // a máscara (menor) vai pro tamanho da foto e vira o alfa
+    let ci = CIImage(cgImage: img)
+    var mci = CIImage(cvPixelBuffer: masc)
+    mci = mci.transformed(by: CGAffineTransform(scaleX: ci.extent.width / mci.extent.width, y: ci.extent.height / mci.extent.height))
+    let vazio = CIImage(color: CIColor(red: 0, green: 0, blue: 0, alpha: 0)).cropped(to: ci.extent)
+    guard let f = CIFilter(name: "CIBlendWithMask") else { sair(["ok": false, "error": "sem CIBlendWithMask"]) }
+    f.setValue(ci, forKey: kCIInputImageKey)
+    f.setValue(vazio, forKey: kCIInputBackgroundImageKey)
+    f.setValue(mci, forKey: kCIInputMaskImageKey)
+    guard let out = f.outputImage else { sair(["ok": false, "error": "a máscara não saiu"]) }
+    let ctx = CIContext(options: nil)
+    guard let cg = ctx.createCGImage(out, from: ci.extent, format: .RGBA8, colorSpace: CGColorSpace(name: CGColorSpace.sRGB)) else { sair(["ok": false, "error": "não montei o PNG"]) }
+    guard let dst = CGImageDestinationCreateWithURL(URL(fileURLWithPath: saida) as CFURL, UTType.png.identifier as CFString, 1, nil) else { sair(["ok": false, "error": "não gravei o PNG"]) }
+    CGImageDestinationAddImage(dst, cg, nil)
+    if !CGImageDestinationFinalize(dst) { sair(["ok": false, "error": "não gravei o PNG"]) }
+    sair(["ok": true, "motor": "vision", "cobertura": (cobertura * 1000).rounded() / 1000, "w": img.width, "h": img.height])
+}
+
+func ler(_ arquivos: [String]) -> Never {
+    var res: [[String: Any]] = []
+    for a in arquivos {
+        guard let img = carregar(a) else { res.append(["arquivo": a, "ok": false]); continue }
+        let w = img.width, h = img.height
+        let t = VNRecognizeTextRequest()
+        t.recognitionLevel = .accurate
+        t.usesLanguageCorrection = false
+        t.recognitionLanguages = ["pt-BR", "en-US"]
+        t.minimumTextHeight = 0.012
+        let r = VNDetectFaceRectanglesRequest()
+        let hd = VNImageRequestHandler(cgImage: img, options: [:])
+        try? hd.perform([t, r])
+        var textos: [[String: Any]] = []
+        for o in t.results ?? [] {
+            guard let c = o.topCandidates(1).first else { continue }
+            textos.append(["texto": c.string, "conf": (Double(c.confidence) * 100).rounded() / 100, "caixa": caixa(o.boundingBox, w, h)])
+        }
+        let rostos = (r.results ?? []).map { caixa($0.boundingBox, w, h) }
+        res.append(["arquivo": a, "ok": true, "w": w, "h": h, "textos": textos, "rostos": rostos])
+    }
+    sair(["ok": true, "quadros": res])
+}
+
+let A = CommandLine.arguments
+if A.count >= 4 && A[1] == "recortar" { recortar(A[2], A[3]) }
+if A.count >= 3 && A[1] == "ler" { ler(Array(A.dropFirst(2))) }
+sair(["ok": false, "error": "uso: visao recortar <entrada> <saida.png> | visao ler <quadro.png>..."])

package/lib/estudio/visao.js

@@ -0,0 +1,60 @@
+/**
+ * visao.js — o Vision do macOS a serviço do motion, sem instalar nada pesado.
+ *
+ *   recortar(entrada, saida) → {ok, motor:'vision', cobertura} | {ok:false, semPessoa?, error}
+ *       o recorte da pessoa (VNGeneratePersonSegmentationRequest, qualidade .accurate) em PNG com alfa.
+ *   ler(quadros)            → {ok, quadros:[{arquivo, w, h, textos:[{texto, conf, caixa}], rostos:[caixa]}]} | {ok:false}
+ *       o texto (VNRecognizeTextRequest) e os rostos de cada quadro: é o "olho" da conferência pós-render.
+ *
+ * O visao/visao.swift é compilado UMA vez com o `swiftc` do sistema (vem com as Command Line Tools) em
+ * ~/.primocode/bin/primo-visao-<hash do fonte>; sem swiftc, roda pelo interpretador `swift` (mais lento); sem nenhum dos
+ * dois (Windows, Linux, Mac sem as ferramentas), disponivel() é false e quem chama segue o caminho de antes
+ * (MediaPipe → moldura no recorte; caixas do layout na conferência). PRIMOCODE_SEM_VISAO=1 desliga (testes).
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+const FONTE = path.join(__dirname, 'visao', 'visao.swift');
+let _bin;   // cache do processo: caminho do binário, 'swift' (interpretador) ou null
+
+function tem(cmd) { const r = spawnSync('/usr/bin/which', [cmd], { encoding: 'utf8' }); return r.status === 0 && String(r.stdout).trim(); }
+
+/** O executável do Vision (compila na 1ª vez). null fora do Mac ou sem as ferramentas do Swift. */
+function binario({ home = os.homedir(), env = process.env } = {}) {
+    if (_bin !== undefined) return _bin;
+    _bin = null;
+    if (process.platform !== 'darwin' || env.PRIMOCODE_SEM_VISAO === '1' || !fs.existsSync(FONTE)) return _bin;
+    const hash = crypto.createHash('sha256').update(fs.readFileSync(FONTE)).digest('hex').slice(0, 10);
+    const alvo = path.join(home, '.primocode', 'bin', 'primo-visao-' + hash);
+    if (fs.existsSync(alvo)) return (_bin = alvo);
+    const swiftc = tem('swiftc');
+    if (swiftc) {
+        fs.mkdirSync(path.dirname(alvo), { recursive: true });
+        const tmp = alvo + '.tmp-' + process.pid;
+        const r = spawnSync(swiftc, ['-O', FONTE, '-o', tmp], { encoding: 'utf8', timeout: 240000 });
+        if (r.status === 0 && fs.existsSync(tmp)) { fs.renameSync(tmp, alvo); return (_bin = alvo); }
+        try { fs.rmSync(tmp, { force: true }); } catch { /* ok */ }
+    }
+    if (tem('swift')) _bin = 'swift';
+    return _bin;
+}
+function disponivel(opc) { return !!binario(opc); }
+
+function rodar(args, timeout) {
+    const b = binario();
+    if (!b) return { ok: false, error: 'sem o Vision (só no macOS com as ferramentas do Swift)' };
+    const cmd = b === 'swift' ? 'swift' : b, todos = b === 'swift' ? [FONTE, ...args] : args;
+    const r = spawnSync(cmd, todos, { encoding: 'utf8', timeout, maxBuffer: 16 * 1024 * 1024 });
+    const linha = String(r.stdout || '').trim().split('\n').pop();
+    try { return JSON.parse(linha); } catch { return { ok: false, error: String(r.stderr || r.error || 'o Vision não respondeu').slice(-300) }; }
+}
+
+function recortar(entrada, saida) { return rodar(['recortar', entrada, saida], 120000); }
+function ler(quadros) { const l = (quadros || []).filter((q) => q && fs.existsSync(q)); return l.length ? rodar(['ler', ...l], 60000 + l.length * 8000) : { ok: false, error: 'sem quadros' }; }
+
+module.exports = { binario, disponivel, recortar, ler, FONTE, _zerar: () => { _bin = undefined; } };

package/lib/local/cerebro.json

@@ -1,9 +1,9 @@
 {
- "origem": "primocode-server 8.20.0 6015327",
+ "origem": "primocode-server 8.20.0 131e585",
  "SYSTEM_NUCLEO": "Você é o PrimoCode, agente de engenharia da ConectaPrimoAI.\n\nCONVERSA OU TRABALHO: cumprimento, agradecimento, pergunta sobre você ou papo\n(\"oi\", \"o que você faz?\") → responda em texto, 1 ou 2 frases, sem tool nenhuma,\ne não invente tarefa que ninguém pediu. Pedido de criar, alterar, ler, rodar ou\nconsertar → EXECUTE, até o fim, sem conversar no meio.\n\nREGRAS ABSOLUTAS (executando):\n1. NUNCA escreva código na resposta. Código vai SEMPRE dentro de uma tool.\n2. NUNCA pergunte ao usuário. Decida e execute.\n3. NUNCA invente ferramenta, serviço, porta ou API: as suas são EXATAMENTE as\n   desta lista. E nunca diga que algo \"não está rodando\" para se esquivar — o\n   que precisa subir, sobe sozinho quando você chama a tool. Prometer o que\n   você não tem, ou culpar um serviço, é o pior erro possível.\n4. Caminhos RELATIVOS (\"index.html\", \"src/game.js\"). Você já está na pasta do\n   projeto: nunca caminho absoluto, nunca \"../\".\n5. Termine SEMPRE com finish(\"frase curta do que foi feito\").\n6. Resposta em texto: no máximo 1 frase, sem markdown.\n7. NUNCA repita uma chamada que já fez. Reformular a mesma busca traz as mesmas\n   fontes; spec e manual são FIXOS — leu uma vez, está lido. Pesquisou e leu a\n   spec? O passo seguinte é CRIAR com o que já tem.\n\nESCOLHENDO A TOOL: arquivo novo → write_file; mudar parte → edit_file (nunca\nreescreva o arquivo inteiro para trocar poucas linhas); várias mudanças no mesmo\narquivo → multi_edit, numa chamada; não sabe onde está → grep (conteúdo) ou glob\n(nome), nunca list_dir (o mapa já está aqui); servidor de pé → run_in_new_terminal.\n\nANTES DE EDITAR, LEIA SÓ O ARQUIVO QUE VAI MUDAR (edit_file exige o texto\nliteral), inteiro e uma vez. Nada de ler outros \"para entender\".\n\nQUANDO FALHA: leia o erro e conserte. Se edit_file disser \"trecho não\nencontrado\", ele devolve \"trechosParecidos\" com as linhas reais — copie de lá.\nNUNCA chame finish dizendo que fez algo que falhou: \"não consegui alterar X\nporque Y\" é melhor que um \"pronto!\" falso.\n\nPLANO: tarefa de 3+ passos começa com write_todos e vai atualizando o status (só\nUMA \"in_progress\" por vez). Tarefa curta não precisa.\n\nCOMO VOCÊ FALA ENQUANTO TRABALHA: antes de uma tool que muda o rumo (conserto,\nconversão, desvio), UMA frase em primeira pessoa com o quê e o porquê (\"o vídeo\nveio em .avi, vou converter para mp4\"); resolvido, \"feito, continuando\". Passo\nóbvio não precisa. NUNCA cite limite, cota, token, modelo, provedor, tentativa\nou erro interno: quem lê vê o trabalho, não o encanamento. Contornou uma\nfalha? Conte o contorno.\n\nMEMÓRIA: você recebe memory-geral.md (o usuário) e o memory.md do projeto.\nRespeite as preferências e decisões que estão lá, e não recomece do zero um\nprojeto que já tem arquivos — veja o mapa antes de escrever. O memory.md do projeto se\ngrava sozinho. Já o memory-geral.md só guarda o que você mandar com\nremember_general: nome, preferência que vale em qualquer projeto, decisão de\nlongo prazo. Sem essa chamada, nada disso sobrevive para a próxima vez.\n\nPROCESSO: ache o alvo (mapa ou grep) → leia só ele → faça → confira → finish.\nCriar do zero: escreva direto, sem ler nada.",
  "SECOES": {
   "pesquisa": "PEDIDO QUE DEPENDE DE FATO DO MUNDO — PESQUISE PRIMEIRO:\nSe o que o usuário pediu envolve algo real (uma empresa, um produto, uma\npessoa, um mercado, um número, um acontecimento), chame pesquisar_referencia\nANTES de criar qualquer coisa, em qualquer esforço. \"Pesquise sobre a empresa X\ne faça slides\" é UM pedido só: pesquisa e depois cria, sem parar para perguntar\ne sem entregar o deck com dado inventado.\n\nUm deck bonito cheio de número inventado é pior que nenhum deck — o usuário\nleva aquilo para uma reunião. Se depois da pesquisa faltar um dado, escreva na\npeça o que você sabe e deixe o buraco explícito (\"faturamento: não divulgado\"),\nnunca um número plausível de sua cabeça.",
-  "estudio": "O ESTÚDIO — VÍDEO, MOTION, SLIDES E ARTE, FEITOS AQUI:\nCada peça é uma PASTA no computador do usuário, e o arquivo final sai pelo\nRemotion (.mp4 no vídeo, .pdf em slides e arte). Nada de link para abrir num\nsite: no fim, o arquivo abre sozinho para o usuário.\n\nFLUXO (vídeo, motion, slides ou arte feitos do zero):\n1. estudio_projeto acao:\"criar\" (titulo, pedido, formato: video | slides | arte).\n2. Empresa ou marca de verdade → estudio_site ANTES, e use as cores, a fonte\n   e a logo que ele devolve em roteiro.marca.\n3. estudio_plano com ROTEIRO: 6 a 12 partes, cada uma com o tipo certo\n   (abertura, numero, lista, passos, contraste, citacao, imagem, grafico,\n   titulo, cta) e a \"fala\" — a frase dita, que não repete a tela. O PrimoCode\n   faz o layout, a voz com entonação, os ícones, a música e os sons. NÃO\n   escreva cenas nem posições à mão.\n4. estudio_render. Para ajustar, mande o roteiro de novo com a mudança.\n\nGRAVAÇÃO DO USUÁRIO (\"edita meu vídeo\", um .mp4/.mov dele): estudio_projeto\ncriar → estudio_video acao:\"importar\" → estudio_video acao:\"editar\" (faz a\nedição inteira: cortes, legenda animada, ícones, zoom, sons) → estudio_render.\nNão monte as cenas à mão antes de tentar o \"editar\". Depois, ajuste só a cena\nque o usuário pedir (estudio_plano cena:N). NUNCA escreva .mp4/.mp3 com\nwrite_file e nunca monte vídeo com ffmpeg na mão.\n\nO ROTEIRO BOM: a primeira parte prende (abertura ou contraste), o miolo prova\n(numero, grafico, lista, imagem) e a última pede ação (cta). Varie os tipos —\ntrês \"titulo\" seguidos parecem slide parado. Título que diz algo (\"Receita\ntriplicou em 18 meses\"), não rótulo (\"Resultados\"). Número de verdade ou\nnenhum. A fala não repete a tela: a tela dá o título, a voz dá o argumento.\n\nSE O USUÁRIO CITAR UM APP (Canva, PowerPoint, CapCut, Premiere…): faça a peça\ncom as ferramentas do Estúdio e avise em uma linha. Se ele insistir no app,\nprocure um MCP dele (mcp_procurar) antes de abrir com o mouse.\n\nDocumento, planilha e PDF não são do Estúdio: faça o arquivo (.docx, .xlsx,\n.pdf) com código, na pasta do projeto.",
+  "estudio": "O ESTÚDIO — VÍDEO, MOTION, SLIDES E ARTE, FEITOS AQUI:\nCada peça é uma PASTA no computador do usuário, e o arquivo final sai pelo\nRemotion (.mp4 no vídeo, .pdf em slides e arte). Nada de link para abrir num\nsite: no fim, o arquivo abre sozinho para o usuário.\n\nFLUXO (vídeo, motion, slides ou arte feitos do zero):\n1. estudio_projeto acao:\"criar\" (titulo, pedido, formato: video | slides | arte).\n2. Empresa ou marca de verdade → estudio_site ANTES, e use as cores, a fonte\n   e a logo que ele devolve em roteiro.marca.\n3. estudio_plano com ROTEIRO: 6 a 12 partes, cada uma com o tipo certo\n   (abertura, numero, lista, passos, contraste, citacao, imagem, grafico,\n   titulo, cta) e a \"fala\" — a frase dita, que não repete a tela. O PrimoCode\n   faz o layout, a voz com entonação, os ícones, a música e os sons. NÃO\n   escreva cenas nem posições à mão.\n4. estudio_render. Para ajustar, mande o roteiro de novo com a mudança.\n\nGRAVAÇÃO DO USUÁRIO FALANDO (\"edita meu vídeo\", \"faz um reels disso\", \"coloca\nlegenda e efeitos\", um .mp4/.mov dele): a edição completa é do editor_pro (o\nmotor do EDIT IA PRO). acao:\"cortar\" com o video → leia a fala que volta (com os\ntempos) → acao:\"montar\" com a pasta e o plano (gancho, pecas, broll) → entregue\n<pasta>/final.mp4 só com o portão PASSOU. Atalho: acao:\"editar\" faz tudo com o\nplano automático. Operações soltas na gravação (só cortar um trecho, juntar,\nexportar) seguem no estudio_video. NUNCA escreva .mp4/.mp3 com write_file e\nnunca monte vídeo com ffmpeg na mão.\n\nO ROTEIRO BOM: a primeira parte prende (abertura ou contraste), o miolo prova\n(numero, grafico, lista, imagem) e a última pede ação (cta). Varie os tipos —\ntrês \"titulo\" seguidos parecem slide parado. Título que diz algo (\"Receita\ntriplicou em 18 meses\"), não rótulo (\"Resultados\"). Número de verdade ou\nnenhum. A fala não repete a tela: a tela dá o título, a voz dá o argumento.\n\nSE O USUÁRIO CITAR UM APP (Canva, PowerPoint, CapCut, Premiere…): faça a peça\ncom as ferramentas do Estúdio e avise em uma linha. Se ele insistir no app,\nprocure um MCP dele (mcp_procurar) antes de abrir com o mouse.\n\nDocumento, planilha e PDF não são do Estúdio: faça o arquivo (.docx, .xlsx,\n.pdf) com código, na pasta do projeto.",
   "navegador": "CONTROLANDO NAVEGADOR E DESKTOP:\nVocê pode AGIR numa página real e no computador inteiro do usuário — qualquer\nprograma, e a própria área de trabalho:\n- Navegador: browser_open abre a página num Chrome controlado; depois\n  browser_click (por texto/seletor), browser_type, browser_key, browser_read\n  (conferir), browser_screenshot. Use para testar o que você criou, preencher\n  formulários, navegar em sites.\n- No DESKTOP você enxerga por NOMES, não por pixels (você não vê imagens):\n  desktop_windows lista as janelas abertas; desktop_focus traz uma para a\n  frente; desktop_elements lê os botões, campos, menus e ícones dela (nome,\n  tipo e posição); desktop_click_element clica pelo NOME.\n- FLUXO PADRÃO no desktop: desktop_open_app (ou desktop_focus se já está\n  aberto) → desktop_elements → desktop_click_element → desktop_type /\n  desktop_key. Depois de agir, confira: desktop_elements de novo (o estado\n  mudou?) ou desktop_windows.\n- desktop_open_app abre qualquer programa pelo nome (\"chrome\", \"bloco de\n  notas\", \"calculadora\"). A janela leva 1-2s: confirme com desktop_windows.\n- Área de trabalho (Windows): desktop_elements com window \"Program Manager\"\n  lista os ícones; ícone abre com desktop_click_element {double: true}.\n- Atalhos: desktop_key aceita combinações — \"ctrl+c\", \"alt+tab\",\n  \"ctrl+shift+t\", \"Enter\", \"win\" (menu Iniciar).\n- desktop_click/desktop_double_click por coordenada e desktop_screenshot são o\n  último recurso, quando a janela não expõe elementos nomeados.\nPrefira sempre NOMES (texto/seletor no navegador, elemento no desktop) a\ncoordenadas fixas. Confira o resultado antes de dizer que terminou.\n\nPESQUISANDO ANTES DE ESCREVER (qualidade):\nVocê não sabe tudo de cor, e chutar assinatura de API é o erro que mais custa\ncaro. pesquisar_referencia abre documentação oficial, exemplos e respostas\nsobre o assunto e devolve o TEXTO delas para você ler. Use quando:\n- for usar biblioteca/framework/API que você não domina com certeza;\n- a mesma tool falhar duas vezes seguidas (pare de tentar, vá ler);\n- o usuário pedir qualidade, ou a tarefa for grande.\nLeia, entenda o padrão e ESCREVA o seu código. Não cole trecho literal de\nterceiros no projeto do usuário; e confira se a API que a fonte cita existe na\nversão que o projeto usa (veja o package.json).",
   "mcp": "FERRAMENTA CERTA: para agir num serviço ou app, use primeiro um MCP (veja\n[mcp]). Sem MCP: mcp_procurar → mcp_conectar → mcp_usar. Mouse/desktop_* só\nquando não houver MCP, API ou CLI. Se o MCP pedir chave, PEÇA ao usuário.",
   "delegar": "DIVIDIR COM ESPECIALISTAS (spawn_agent):\nDELEGUE quando a tarefa tem 2+ partes independentes, mexe em mais de 3\narquivos ou junta pesquisa e construção. Como: write_todos com as partes e,\nNA MESMA resposta, um spawn_agent por parte: rodam em paralelo. O prompt de\ncada um é completo (ele NÃO vê esta conversa): o que fazer, em que arquivos,\no contrato com as outras partes (rotas, nomes, formato) e como provar que\nficou pronto. Diga QUEM faz em `especialista`: frontend (tela, HTML, CSS) ·\nbackend (API, banco, autenticação) · testes (escrever e rodar testes,\nreproduzir bug) · design (identidade visual, paleta, ícones) · dados (CSV,\nplanilha, análise) · revisor (lê e aponta defeitos, não conserta) · ambiente\n(instalar, configurar, fazer rodar). Parte que depende de outra vai na rodada\nseguinte, com a entrega dela no prompt. No fim, um revisor; o que ele apontar\nvolta para quem escreveu.\nNÃO delegue edição pequena (um arquivo, um ajuste): faça você.\nconstruir_app é para UM app novo do zero; projeto existente ou partes\ndiferentes, spawn_agent.",
@@ -710,7 +710,7 @@
    "type": "function",
    "function": {
     "name": "estudio_motion",
-    "description": "A MAQUINA DE MOTION: voce so preenche o JSON (assunto, formato, marca, cenas) e ela monta no After Effects, poe os sons no tempo, mixa a -14 LUFS e confere os quadros. Prefira esta a escrever JSX. Tipos de cena: gancho{titulo,sub} celular{titulo,tela,toques[]} numero{valor,rotulo} lista{titulo,itens[]} antes_depois{antes,depois} icones{titulo,itens[]} citacao{texto,autor} cta{titulo,botao}. Marque a palavra-chave com *asteriscos*. Sem cenas, ela monta o roteiro padrao do assunto.",
+    "description": "A MAQUINA DE MOTION: voce so preenche o JSON (assunto, formato, marca, cenas) e ela monta no After Effects, poe os sons no tempo, mixa a -14 LUFS e confere os quadros. Prefira esta a escrever JSX. Cada cena leva um papel (gancho|problema|processo|prova|virada|cta) e o conteudo (titulo, itens[], valor, rotulo, antes, depois, texto, autor, botao, fala); o DIRETOR escolhe a primitiva (38: cinetico, interface, cursor, prompt, mergulho, barras, linha, mapa, chat, notificacoes, relogio, calendario, funil, carimbo, heroi, split...), as 15 transicoes, a camera e a tipografia, com assinatura propria por video. Pode mandar tipo, transicoes, camera, tipografia, semente. Elementos reais do assunto (3D, GIF, logos), som real CC0, voz com tempo por palavra e legenda. Marque a palavra-chave com *asteriscos*.",
     "parameters": {
      "type": "object",
      "properties": {
@@ -746,7 +746,51 @@
        "items": {
         "type": "object"
        },
-       "description": "[{tipo, dur, ...campos do tipo}]; de 1 a 2,5 s por cena e no minimo 5 cenas para 15 s"
+       "description": "[{papel, tipo?, fala?, titulo, itens, valor, rotulo, antes, depois, texto, autor, botao}]; o diretor completa o tipo; minimo 5 cenas para 15 s"
+      },
+      "elementos": {
+       "type": "array",
+       "items": {
+        "type": "string"
+       },
+       "description": "Termos dos elementos reais do assunto (\"pao\", \"relogio\"); o diretor completa ate 3 ou mais"
+      },
+      "transicoes": {
+       "type": "array",
+       "items": {
+        "type": "string"
+       },
+       "description": "Opcional: encolhe|empurra|mascara|zoom|flash|persiana|chicote|desfoque|cortina|pontos|giro|tremor|abre|dissolve|corte"
+      },
+      "camera": {
+       "type": "string",
+       "enum": [
+        "deriva",
+        "pulso",
+        "mao",
+        "trilho",
+        "orbita",
+        "push",
+        "chicote",
+        "cinema"
+       ]
+      },
+      "tipografia": {
+       "type": "string",
+       "enum": [
+        "editorial",
+        "poster",
+        "tecnica",
+        "manuscrita",
+        "pesada",
+        "serifa_fina",
+        "arredondada",
+        "geometrica"
+       ]
+      },
+      "semente": {
+       "type": "number",
+       "description": "Semente do video; sem ela cada video sorteia uma nova e foge das assinaturas recentes"
       },
       "voz": {
        "type": "string",
@@ -771,6 +815,10 @@
       "entrega": {
        "type": "boolean",
        "description": "Pacote pra postar (mp4, capa, legenda .srt, post.txt); padrao true"
+      },
+      "previa": {
+       "type": "boolean",
+       "description": "true: rascunho em meia resolucao, em segundos e sem mix final, para a pessoa aprovar antes do final"
       }
      },
      "required": [
@@ -901,6 +949,51 @@
     }
    }
   },
+  {
+   "type": "function",
+   "function": {
+    "name": "editor_pro",
+    "description": "Edicao COMPLETA de video FALADO da pessoa (motor EDIT IA PRO): corte da melhor tomada sem respiro, voz limpa no volume certo, legenda animada, gancho, camera viva, pecas, b-roll, sons, trilha com ducking e portao de qualidade. acao \"cortar\" devolve a fala com tempos; \"montar\" recebe o plano; \"editar\" faz tudo de uma vez. Sai em <pasta>/final.mp4.",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "acao": {
+       "type": "string",
+       "enum": [
+        "editar",
+        "cortar",
+        "montar",
+        "preparar",
+        "estado"
+       ]
+      },
+      "video": {
+       "type": "string",
+       "description": "caminho da gravacao"
+      },
+      "pasta": {
+       "type": "string",
+       "description": "a pasta da edicao (devolvida por cortar)"
+      },
+      "prompt": {
+       "type": "string",
+       "description": "nomes dificeis da fala, separados por virgula"
+      },
+      "plano": {
+       "type": "object",
+       "description": "{gancho:\"Texto *destaque*\", pecas:[...], broll:[{busca,de,ate,rotulo}], blocos?, estilo?, legenda?, correcoes?}"
+      },
+      "trilha": {
+       "type": "string",
+       "description": "auto | caminho de um audio | nenhuma"
+      }
+     },
+     "required": [
+      "acao"
+     ]
+    }
+   }
+  },
   {
    "type": "function",
    "function": {
@@ -2236,7 +2329,7 @@
    "type": "function",
    "function": {
     "name": "estudio_motion",
-    "description": "A MAQUINA DE MOTION: voce so preenche o JSON (assunto, formato, marca, cenas) e ela monta no After Effects, poe os sons no tempo, mixa a -14 LUFS e confere os quadros. Prefira esta a escrever JSX. Tipos de cena: gancho{titulo,sub} celular{titulo,tela,toques[]} numero{valor,rotulo} lista{titulo,itens[]} antes_depois{antes,depois} icones{titulo,itens[]} citacao{texto,autor} cta{titulo,botao}. Marque a palavra-chave com *asteriscos*. Sem cenas, ela monta o roteiro padrao do assunto.",
+    "description": "A MAQUINA DE MOTION: voce so preenche o JSON (assunto, formato, marca, cenas) e ela monta no After Effects, poe os sons no tempo, mixa a -14 LUFS e confere os quadros. Prefira esta a escrever JSX. Cada cena leva um papel (gancho|problema|processo|prova|virada|cta) e o conteudo (titulo, itens[], valor, rotulo, antes, depois, texto, autor, botao, fala); o DIRETOR escolhe a primitiva (38: cinetico, interface, cursor, prompt, mergulho, barras, linha, mapa, chat, notificacoes, relogio, calendario, funil, carimbo, heroi, split...), as 15 transicoes, a camera e a tipografia, com assinatura propria por video. Pode mandar tipo, transicoes, camera, tipografia, semente. Elementos reais do assunto (3D, GIF, logos), som real CC0, voz com tempo por palavra e legenda. Marque a palavra-chave com *asteriscos*.",
     "parameters": {
      "type": "object",
      "properties": {
@@ -2272,7 +2365,51 @@
        "items": {
         "type": "object"
        },
-       "description": "[{tipo, dur, ...campos do tipo}]; de 1 a 2,5 s por cena e no minimo 5 cenas para 15 s"
+       "description": "[{papel, tipo?, fala?, titulo, itens, valor, rotulo, antes, depois, texto, autor, botao}]; o diretor completa o tipo; minimo 5 cenas para 15 s"
+      },
+      "elementos": {
+       "type": "array",
+       "items": {
+        "type": "string"
+       },
+       "description": "Termos dos elementos reais do assunto (\"pao\", \"relogio\"); o diretor completa ate 3 ou mais"
+      },
+      "transicoes": {
+       "type": "array",
+       "items": {
+        "type": "string"
+       },
+       "description": "Opcional: encolhe|empurra|mascara|zoom|flash|persiana|chicote|desfoque|cortina|pontos|giro|tremor|abre|dissolve|corte"
+      },
+      "camera": {
+       "type": "string",
+       "enum": [
+        "deriva",
+        "pulso",
+        "mao",
+        "trilho",
+        "orbita",
+        "push",
+        "chicote",
+        "cinema"
+       ]
+      },
+      "tipografia": {
+       "type": "string",
+       "enum": [
+        "editorial",
+        "poster",
+        "tecnica",
+        "manuscrita",
+        "pesada",
+        "serifa_fina",
+        "arredondada",
+        "geometrica"
+       ]
+      },
+      "semente": {
+       "type": "number",
+       "description": "Semente do video; sem ela cada video sorteia uma nova e foge das assinaturas recentes"
       },
       "voz": {
        "type": "string",
@@ -2297,6 +2434,10 @@
       "entrega": {
        "type": "boolean",
        "description": "Pacote pra postar (mp4, capa, legenda .srt, post.txt); padrao true"
+      },
+      "previa": {
+       "type": "boolean",
+       "description": "true: rascunho em meia resolucao, em segundos e sem mix final, para a pessoa aprovar antes do final"
       }
      },
      "required": [
@@ -2427,6 +2568,51 @@
     }
    }
   },
+  {
+   "type": "function",
+   "function": {
+    "name": "editor_pro",
+    "description": "Edicao COMPLETA de video FALADO da pessoa (motor EDIT IA PRO): corte da melhor tomada sem respiro, voz limpa no volume certo, legenda animada, gancho, camera viva, pecas, b-roll, sons, trilha com ducking e portao de qualidade. acao \"cortar\" devolve a fala com tempos; \"montar\" recebe o plano; \"editar\" faz tudo de uma vez. Sai em <pasta>/final.mp4.",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "acao": {
+       "type": "string",
+       "enum": [
+        "editar",
+        "cortar",
+        "montar",
+        "preparar",
+        "estado"
+       ]
+      },
+      "video": {
+       "type": "string",
+       "description": "caminho da gravacao"
+      },
+      "pasta": {
+       "type": "string",
+       "description": "a pasta da edicao (devolvida por cortar)"
+      },
+      "prompt": {
+       "type": "string",
+       "description": "nomes dificeis da fala, separados por virgula"
+      },
+      "plano": {
+       "type": "object",
+       "description": "{gancho:\"Texto *destaque*\", pecas:[...], broll:[{busca,de,ate,rotulo}], blocos?, estilo?, legenda?, correcoes?}"
+      },
+      "trilha": {
+       "type": "string",
+       "description": "auto | caminho de um audio | nenhuma"
+      }
+     },
+     "required": [
+      "acao"
+     ]
+    }
+   }
+  },
   {
    "type": "function",
    "function": {

package/lib/local/motor.js

@@ -18,6 +18,7 @@ const cerebro = require('./cerebro.json');
 const entrada = require('./entrada.js');
 const provedor = require('./provedor.js');
 const catalogo = require('../catalogo.js');
+const chamadaTorta = require('../chamada-torta');
 
 // A conversa pode ocupar isto, em tokens, além do prompt e das ferramentas.
 // Folgado: os modelos de hoje têm 128 mil ou mais de contexto.
@@ -191,8 +192,10 @@ async function requestAct(_servidor, body, emit) {
     });
     chamadas.forEach((tc, i) => {
         if (!tc || !tc.name) return;
-        let args = {};
-        try { args = JSON.parse(tc.arguments || '{}'); } catch { /* o loop pede de novo */ }
+        /* JSON quebrado: tenta recuperar; se não der, o act.js devolve o erro
+           (com os argumentos crus) ao modelo — ver lib/chamada-torta.js. */
+        const rec = chamadaTorta.recuperar(tc.arguments);
+        const args = rec.ok ? rec.args : chamadaTorta.marcar(tc.arguments);
         emit({ tool_call: { id: tc.id || `local_${Date.now()}_${i}`, name: tc.name, arguments: args } });
     });
     if (texto_) emit({ assistant_message: { content: texto_ } });

package/lib/mcp.js

@@ -54,28 +54,117 @@ function servidores(pasta = process.cwd()) {
     const out = process.env.PRIMOCODE_SEM_MCP === '1' ? {} : { ...PADRAO };
     for (const arq of [CONFIG, path.join(pasta, '.mcp.json')]) {
         const j = lerJson(arq);
-        for (const [nome, s] of Object.entries((j && j.mcpServers) || {})) if (s && (s.command || s.url)) out[nome] = s;
+        const doProjeto = arq !== CONFIG;
+        for (const [nome, s] of Object.entries((j && j.mcpServers) || {})) {
+            if (s && (s.command || s.url)) out[nome] = doProjeto ? marcarProjeto(s, nome, pasta) : s;
+        }
     }
     return out;
 }
 
+/* ── SERVIDOR QUE VEM DO PROJETO ─────────────────────────────────────────
+ * O .mcp.json de um repo clonado roda comando na máquina de quem abre. Então
+ * servidor do PROJETO (não o do ~/.primocode/mcp.json) só sobe com o sim da
+ * pessoa, mesmo no modo auto — lembrado por projeto + configuração exata
+ * (hash de command+args+env…): mudou o .mcp.json, pergunta de novo. Sem
+ * ninguém para perguntar (headless), não sobe. */
+const APROVADOS = path.join(CASA, 'mcp-aprovados.json');
+let perguntador = null;   // async ({ nome, pasta, def, resumo }) → boolean
+let filaDePerguntas = Promise.resolve();
+
+function marcarProjeto(def, nome, pasta) {
+    const c = { ...def };
+    Object.defineProperty(c, '_projeto', { value: { nome, pasta: path.resolve(pasta) }, enumerable: false });
+    return c;
+}
+
+function hashDoServidor(def) {
+    const d = def || {};
+    const base = JSON.stringify([d.type || '', d.command || '', d.args || [], d.env || {}, d.url || '', d.headers || {}]);
+    return require('crypto').createHash('sha256').update(base).digest('hex');
+}
+
+function usarPerguntador(fn) { perguntador = typeof fn === 'function' ? fn : null; }
+
+function jaAprovado(pasta, def) {
+    const j = lerJson(APROVADOS) || {};
+    return !!(j[path.resolve(pasta)] || {})[hashDoServidor(def)];
+}
+
+function aprovarProjeto(pasta, def, nome = '') {
+    const j = lerJson(APROVADOS) || {};
+    const k = path.resolve(pasta);
+    j[k] = j[k] || {};
+    j[k][hashDoServidor(def)] = nome || true;
+    fs.mkdirSync(CASA, { recursive: true });
+    fs.writeFileSync(APROVADOS, JSON.stringify(j, null, 2), { mode: 0o600 });
+}
+
+function resumoDoServidor(def) {
+    return def.url ? `${def.url}` : [def.command, ...(def.args || [])].join(' ');
+}
+
+/** Lança se o servidor do projeto não foi aprovado (e não há como perguntar). */
+async function autorizarProjeto(def, nomeDado) {
+    const info = def && def._projeto;
+    if (!info) return;
+    const nome = nomeDado || info.nome;
+    if (jaAprovado(info.pasta, def)) return;
+    const recusa = (porque) => {
+        process.stderr.write(`[mcp] servidor "${nome}" do .mcp.json do projeto NÃO foi iniciado: ${porque}\n`);
+        throw new Error(`o servidor MCP "${nome}" vem do .mcp.json deste projeto e não foi aprovado (${porque}). `
+            + 'Rode o PrimoCode neste terminal para aprovar, ou mova o servidor para ~/.primocode/mcp.json.');
+    };
+    if (!perguntador) recusa('sem terminal para pedir o sim');
+    const ok = await (filaDePerguntas = filaDePerguntas.catch(() => {}).then(async () => {
+        if (jaAprovado(info.pasta, def)) return true;
+        const r = await perguntador({ nome, pasta: info.pasta, def, resumo: resumoDoServidor(def) });
+        if (r) aprovarProjeto(info.pasta, def, nome);
+        return !!r;
+    }));
+    if (!ok) recusa('a pessoa não aprovou');
+}
+
+/* Variáveis que o `${VAR}` de um servidor do PROJETO pode ler. O resto vira
+   vazio: um .mcp.json clonado não pode mandar GITHUB_TOKEN para uma URL. Quem
+   quer liberar mais escreve "envPermitidas": ["X"] no ~/.primocode/mcp.json. */
+const ENV_PERMITIDAS = ['HOME', 'USER', 'PATH', 'PWD', 'TMPDIR', 'LANG', 'SHELL'];
+
+function permitidasDoUsuario() {
+    const j = lerJson(CONFIG);
+    return Array.isArray(j && j.envPermitidas) ? j.envPermitidas.map(String) : [];
+}
+
 /** Abre um servidor, faz o aperto de mão e devolve {pedir, fechar}. */
 /* `${VAR}` no argumento vira o valor do env. Sem shell no meio (spawn puro),
    ninguém expandiria — e é assim que o token entra no header do mcp-remote
    sem ficar escrito duas vezes no mcp.json. */
-function expandir(args, env) {
-    return (args || []).map((a) => String(a).replace(/\$\{([A-Z0-9_]+)\}/g, (_, k) => (env[k] != null ? env[k] : '')));
+function expandir(args, env, { projeto = false, permitidas = [], aviso = null } = {}) {
+    const livres = new Set([...ENV_PERMITIDAS, ...permitidas]);
+    return (args || []).map((a) => String(a).replace(/\$\{([A-Z0-9_]+)\}/g, (_, k) => {
+        if (projeto && !livres.has(k)) {
+            (aviso || ((m) => process.stderr.write(`[mcp] ${m}\n`)))(`\${${k}} no .mcp.json do projeto não é permitida e virou vazia`);
+            return '';
+        }
+        return env[k] != null ? env[k] : '';
+    }));
+}
+
+/** O que o `${VAR}` deste servidor pode ver: o do projeto só lê a lista permitida. */
+function opcoesDeExpansao(def) {
+    return def && def._projeto ? { projeto: true, permitidas: [...permitidasDoUsuario(), ...Object.keys(def.env || {})] } : {};
 }
 
 /** Sobe/abre o servidor: `url` → HTTP, senão stdio. Mesma interface: {pedir, fechar}. */
-function conectar(def, opcoes = {}) {
+async function conectar(def, opcoes = {}) {
+    await autorizarProjeto(def, opcoes.nome);
     return def && def.url ? conectarHttp(def, opcoes) : conectarStdio(def, opcoes);
 }
 
 function conectarStdio(def, { tetoMs = 60000 } = {}) {
     return new Promise((resolve, reject) => {
         const env = { ...process.env, ...(def.env || {}) };
-        const p = spawn(def.command, expandir(def.args, env), { env, stdio: ['pipe', 'pipe', 'pipe'] });
+        const p = spawn(def.command, expandir(def.args, env, opcoesDeExpansao(def)), { env, stdio: ['pipe', 'pipe', 'pipe'] });
         let buf = '', id = 0;
         const espera = new Map();
         const relogio = setTimeout(() => { try { p.kill(); } catch {} reject(new Error('o servidor MCP não respondeu')); }, tetoMs);
@@ -154,7 +243,7 @@ function conectarHttp(def, { tetoMs = 60000, nome, buscar = globalThis.fetch } =
         const env = { ...process.env, ...(def.env || {}) };
         // ID token da conta do PrimoCode já logada (o preset primocode-clube usa no lugar de OAuth).
         if (env.PRIMOCODE_ID_TOKEN == null) { try { env.PRIMOCODE_ID_TOKEN = require('./config.js').tokenDaConta() || ''; } catch { env.PRIMOCODE_ID_TOKEN = ''; } }
-        for (const [k, v] of Object.entries(def.headers || {})) h[k.toLowerCase()] = expandir([v], env)[0];
+        for (const [k, v] of Object.entries(def.headers || {})) h[k.toLowerCase()] = expandir([v], env, opcoesDeExpansao(def))[0];
         const tk = nome && lerTokens()[nome];
         if (tk && tk.access_token && !h.authorization) h.authorization = `Bearer ${tk.access_token}`;
         if (sessao) h['mcp-session-id'] = sessao;
@@ -264,6 +353,7 @@ function ouvirCallback(estado, prazoMs) {
 async function entrar(nome, { pasta, abrir = abrirUrl, aviso = () => {}, buscar = globalThis.fetch, prazoMs = 5 * 60000 } = {}) {
     const def = servidores(pasta)[nome];
     if (!def || !def.url) return { ok: false, error: `"${nome}" não é um servidor MCP remoto (type http com url) — veja primocode mcp list` };
+    try { await autorizarProjeto(def, nome); } catch (e) { return { ok: false, error: e.message }; }
     let cb;
     try {
         // Sem token (o do header manual não conta): o 401 diz onde está o OAuth.
@@ -642,6 +732,14 @@ function dica(pasta) {
 /** `primocode mcp …` */
 async function main(argv) {
     const [op, ...resto] = argv;
+    if (!perguntador && process.stdin.isTTY && process.stdout.isTTY) {
+        perguntador = ({ nome, resumo }) => new Promise((res) => {
+            const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
+            rl.question(`O servidor MCP "${nome}" vem do .mcp.json deste projeto e vai rodar: ${resumo}\nIniciar? (s/N) `, (r) => {
+                rl.close(); res(/^(s|sim|y|yes)\b/i.test(String(r).trim()));
+            });
+        });
+    }
     const json = (() => { const i = resto.indexOf('--json'); try { return i >= 0 ? JSON.parse(resto[i + 1] || '{}') : {}; } catch { return null; } })();
     try {
         if (!op || op === 'help') {
@@ -718,4 +816,4 @@ async function main(argv) {
     }
 }
 
-module.exports = { servidores, conectar, listar, chamar, usar, dica, main, procurar, doRegistro, conectarNovo, CURADOS, expandir, entrar, sair, renovarToken };
+module.exports = { usarPerguntador, aprovarProjeto, jaAprovado, hashDoServidor, ENV_PERMITIDAS, servidores, conectar, listar, chamar, usar, dica, main, procurar, doRegistro, conectarNovo, CURADOS, expandir, entrar, sair, renovarToken };