primocode 11.3.3 → 11.5.0

package/kits/3d/montador.js

@@ -0,0 +1,142 @@
+/* montador.js — recebe um ROTEIRO POR ETAPAS e monta a cena: peças, câmera e ação.
+ *
+ * A IA só escolhe peças do catálogo e escreve o roteiro; ela não desenha nada.
+ * Cada etapa mostra o PROCESSO acontecendo (a caçamba levanta e a massa cai, o
+ * rolo passa por cima da massa), por isso a ação é parte do roteiro, não enfeite.
+ *
+ *   roteiro = { ceu, etapas: [{
+ *     id, dur, titulo, legenda,
+ *     camera: { de:[x,y,z], para:[x,y,z], alvo:[x,y,z] | alvo:'peçaId', alvoPara, fov },
+ *     pecas:  [{ id, tipo, pos:[x,y,z], giro, aparece, ...params da peça }],
+ *     acoes:  [{ em, dur, quem, faz, ... }],
+ *     falas:  [{ quem, de, ate, palavras:[{de,ate}] }]
+ *   }] }
+ *
+ * `faz`:  mover {para:[x,z], de?, anim?:'andar'|'correr', reversa?, ease?:'linear'|'suave'}
+ *         anim  {nome}                       personagem faz uma animação no intervalo
+ *         api   {metodo, de, para, ease?}    qualquer articulação da peça (despejar, massa, subir...)
+ *         virar {para: rad}
+ *
+ * A cena é uma FUNÇÃO PURA do tempo: `atualizar(t)` pode ser chamada em qualquer
+ * ordem (render em paralelo, quadro a quadro). Nada de Math.random nem estado. */
+import { THREE, clamp, lerp, suave, pop } from './base.js';
+import { criar } from './catalogo.js';
+import { bocaDe } from './animacoes.js';
+
+const ease = (nome, k) => (nome === 'linear' ? clamp(k) : suave(k));
+const v3 = (a, d = [0, 0, 0]) => new THREE.Vector3(...(a || d));
+
+export function montar(roteiro, { aspecto = 9 / 16 } = {}) {
+    const cena = new THREE.Scene();
+    const ceu = (roteiro.ceu && roteiro.ceu[1]) || '#cfeaff';
+    cena.background = new THREE.Color(roteiro.ceu ? roteiro.ceu[0] : '#8fd0ff');
+    cena.fog = new THREE.Fog(ceu, 55, 130);
+    cena.add(new THREE.HemisphereLight('#ffffff', '#b59a7a', 1.15));
+    const sol = new THREE.DirectionalLight('#fff1d6', 2.4); sol.position.set(14, 24, 10); sol.castShadow = true;
+    sol.shadow.mapSize.set(2048, 2048); Object.assign(sol.shadow.camera, { left: -30, right: 30, top: 30, bottom: -30, near: 1, far: 80 }); sol.shadow.bias = -0.0006;
+    cena.add(sol);
+    const horizonte = new THREE.Mesh(new THREE.PlaneGeometry(600, 600), new THREE.MeshStandardMaterial({ color: roteiro.horizonte || '#8fc46b', roughness: 1 }));
+    horizonte.rotation.x = -Math.PI / 2; horizonte.position.y = -0.62; horizonte.receiveShadow = true; cena.add(horizonte);
+    const camera = new THREE.PerspectiveCamera(42, aspecto, 0.1, 400);
+
+    // as etapas no tempo
+    let ini = 0;
+    const etapas = roteiro.etapas.map((e) => { const x = { ...e, ini, fim: ini + e.dur }; ini += e.dur; return x; });
+    const duracao = ini;
+
+    // as peças: nascem na etapa que as cita (`aparece` = atraso dentro da etapa)
+    const pecas = new Map();
+    for (const e of etapas) for (const d of e.pecas || []) {
+        if (pecas.has(d.id)) throw new Error(`peça duplicada: ${d.id}`);
+        const { id, tipo, pos, giro, aparece, sai, ...params } = d;
+        const obj = criar(tipo, params);
+        cena.add(obj);
+        pecas.set(id, { id, tipo, obj, api: obj.userData.api || {}, pos: pos || [0, 0, 0], giro: giro || 0, t0: e.ini + (aparece || 0), t1: sai != null ? e.ini + sai : Infinity, cron: [] });
+    }
+    // as ações em ordem, com o ponto de partida resolvido (mover/virar encadeiam)
+    const acoes = [];
+    for (const e of etapas) for (const a of e.acoes || []) {
+        const p = pecas.get(a.quem);
+        if (!p) throw new Error(`ação sobre peça que não existe: ${a.quem}`);
+        acoes.push({ ...a, p, ini: e.ini + (a.em || 0), fim: e.ini + (a.em || 0) + (a.dur || 1) });
+    }
+    acoes.sort((a, b) => a.ini - b.ini);
+    for (const p of pecas.values()) p.fim = { x: p.pos[0], z: p.pos[2], yaw: p.giro, dist: 0 };
+    for (const a of acoes) {
+        const f = a.p.fim;
+        if (a.faz === 'mover') {
+            a.de = a.de || [f.x, f.z]; const dx = a.para[0] - a.de[0], dz = a.para[1] - a.de[1];
+            a.len = Math.hypot(dx, dz); a.yaw0 = f.yaw; a.yaw = a.reversa ? f.yaw : (a.len > 0.01 ? Math.atan2(dx, dz) : f.yaw);
+            a.dist0 = f.dist; f.x = a.para[0]; f.z = a.para[1]; f.yaw = a.yaw; f.dist += a.len * (a.reversa ? -1 : 1);
+        } else if (a.faz === 'virar') { a.de = f.yaw; f.yaw = a.para; }
+    }
+
+    const falas = etapas.flatMap((e) => (e.falas || []).map((f) => ({ ...f, de: e.ini + f.de, ate: e.ini + f.ate, palavras: (f.palavras || [{ de: f.de, ate: f.ate }]).map((w) => ({ ...w, de: w.de + e.ini, ate: w.ate + e.ini })) })));
+
+    function etapaEm(t) {
+        let i = etapas.findIndex((e) => t < e.fim); if (i < 0) i = etapas.length - 1;
+        const e = etapas[i]; return { i, e, local: clamp(t - e.ini, 0, e.dur), k: clamp((t - e.ini) / e.dur) };
+    }
+
+    const alvoPonto = (a, t) => (typeof a === 'string' ? (() => { const p = pecas.get(a); return p ? p.obj.position.clone().add(new THREE.Vector3(0, 0.8, 0)) : v3(); })() : v3(a));
+
+    function atualizar(t) {
+        const T = clamp(t, 0, duracao);
+        // 1. reset: cada peça na pose de origem (a ordem dos quadros não importa)
+        for (const p of pecas.values()) {
+            const vivo = T >= p.t0 && T < p.t1;
+            p.obj.visible = vivo; if (!vivo) continue;
+            p.obj.position.set(p.pos[0], p.pos[1], p.pos[2]); p.obj.rotation.set(0, p.giro, 0);
+            p.obj.scale.setScalar((p.obj.userData.escalaBase = p.obj.userData.escalaBase || p.obj.scale.x) * (p.t0 <= 0 ? 1 : Math.max(0.001, pop((T - p.t0) / 0.5))));
+            p.anim = 'parado'; p.op = {}; p.dist = 0;
+        }
+        // 2. as ações em ordem de início; o que já acabou fica no valor final
+        for (const a of acoes) {
+            const p = a.p; if (!p.obj.visible || T < a.ini && a.faz === 'anim') continue;
+            const k = clamp((T - a.ini) / (a.fim - a.ini)), ativa = T >= a.ini && T < a.fim;
+            if (a.faz === 'mover') {
+                const e = ease(a.ease, k);
+                p.obj.position.x = lerp(a.de[0], a.para[0], e); p.obj.position.z = lerp(a.de[1], a.para[1], e);
+                p.obj.rotation.y = T >= a.ini ? a.yaw : a.yaw0;
+                p.dist = a.dist0 + a.len * e * (a.reversa ? -1 : 1);
+                if (ativa && p.tipo === 'personagem') { p.anim = a.anim || 'andar'; p.op = { vel: a.vel }; }
+            } else if (a.faz === 'virar') {
+                p.obj.rotation.y = lerp(a.de, a.para, suave(k));
+            } else if (a.faz === 'anim') {
+                if (ativa) { p.anim = a.nome; p.op = a.op || {}; }
+            } else if (a.faz === 'api') {
+                const fn = p.api[a.metodo]; if (!fn) throw new Error(`${p.tipo} não tem api.${a.metodo}`);
+                fn(lerp(a.de, a.para, ease(a.ease, k)), T - a.ini);
+            }
+        }
+        // 3. rodas, personagem e processos que dependem do estado
+        for (const p of pecas.values()) {
+            if (!p.obj.visible) continue;
+            if (p.api.rolar) p.api.rolar(p.dist);
+            if (p.api.animar) {
+                const f = falas.find((x) => x.quem === p.id && T >= x.de && T <= x.ate);
+                if (f && (p.anim === 'parado')) p.anim = 'falar';
+                p.api.animar(p.anim, T, { ...p.op, boca: f ? bocaDe(T, f.palavras) : null });
+            }
+            if (p.api.atualizar) p.api.atualizar(T);
+        }
+        // 4. câmera
+        const { e, k } = etapaEm(T), c = e.camera || {}, ke = suave(k);
+        camera.position.lerpVectors(v3(c.de, [0, 12, 20]), v3(c.para || c.de, [0, 12, 20]), ke);
+        const a0 = alvoPonto(c.alvo || [0, 1, 0], T), a1 = alvoPonto(c.alvoPara || c.alvo || [0, 1, 0], T);
+        camera.lookAt(a0.lerp(a1, ke)); camera.fov = c.fov || 42; camera.updateProjectionMatrix();
+    }
+
+    return { cena, camera, duracao, etapas, atualizar, etapaEm, pecas, falas };
+}
+
+/** Confere o roteiro SEM montar (a IA erra o nome de peça: melhor dizer cedo). */
+export function conferir(roteiro) {
+    const erros = [], ids = new Set();
+    (roteiro.etapas || []).forEach((e, i) => {
+        if (!(e.dur > 0)) erros.push(`etapa ${i}: sem dur`);
+        for (const p of e.pecas || []) { if (ids.has(p.id)) erros.push(`peça repetida: ${p.id}`); ids.add(p.id); }
+        for (const a of e.acoes || []) if (!ids.has(a.quem)) erros.push(`etapa ${i}: ação em "${a.quem}", que ainda não existe`);
+    });
+    return erros;
+}

package/kits/3d/package.json

@@ -0,0 +1 @@
+{ "name": "primocode-3d", "private": true, "type": "module", "description": "Biblioteca de pecas 3D e montador de maquete (Three.js puro)." }

package/kits/3d/personagem.js

@@ -0,0 +1,86 @@
+/* personagem.js — o boneco articulado (fofinho, low-poly). Serve para QUALQUER
+ * papel: troca a roupa, a pele e o capacete, as animações são as mesmas.
+ *
+ *   criarPersonagem({ pele, roupa, calca, capacete, cabelo, escala })
+ *
+ * A pose é função pura do tempo: `animar(p, nome, t)` zera e escreve a pose, por
+ * isso o render pode pular de quadro e fora de ordem (render em paralelo). */
+import { THREE, mat, caixa, esfera, capsula, cilindro, grupo, em } from './base.js';
+
+const BRACO = 0.3, PERNA = 0.36;
+
+function membro(len, r, cor, ponta) {
+    // pivô no topo; o segmento desce pela origem
+    const g = grupo(em(capsula(r, len - r * 2, cor), 0, -len / 2, 0));
+    if (ponta) g.add(em(ponta, 0, -len, 0));
+    return g;
+}
+
+export function criarPersonagem({ pele = '#f2c9a0', roupa = '#2f80ed', calca = '#374151', capacete = null, cabelo = '#3b2a20', escala = 1 } = {}) {
+    const raiz = new THREE.Group();
+    const quadril = grupo(); quadril.position.y = PERNA * 2 + 0.06;
+    const torso = grupo(em(caixa(0.5, 0.58, 0.32, roupa), 0, 0.3, 0));
+    quadril.add(torso);
+
+    // cabeça: esfera achatada, olhos, boca (a elipse que abre) e chapéu/cabelo
+    const cabeca = grupo(); cabeca.position.y = 0.66;
+    cabeca.add(em(esfera(0.27, pele), 0, 0.27, 0));
+    const olhos = [-1, 1].map((s) => { const o = esfera(0.045, '#1b1b1f'); o.castShadow = false; o.position.set(s * 0.1, 0.31, 0.235); cabeca.add(o); return o; });
+    const boca = esfera(0.07, '#7a1f2b'); boca.castShadow = false; boca.position.set(0, 0.17, 0.25); boca.scale.set(1, 0.12, 0.4); cabeca.add(boca);
+    const nariz = esfera(0.035, pele); nariz.position.set(0, 0.24, 0.265); cabeca.add(nariz);
+    [-1, 1].forEach((s) => { const b = esfera(0.05, '#f59a9a'); b.castShadow = false; b.position.set(s * 0.17, 0.2, 0.2); b.scale.set(1, 0.6, 0.4); cabeca.add(b); });
+    const hat = capacete
+        ? grupo(em(new THREE.Mesh(new THREE.SphereGeometry(0.29, 14, 8, 0, Math.PI * 2, 0, Math.PI / 2), mat(capacete)), 0, 0.33, 0),
+            em(cilindro(0.34, 0.34, 0.035, capacete), 0, 0.335, 0.03))
+        : em(new THREE.Mesh(new THREE.SphereGeometry(0.285, 14, 8, 0, Math.PI * 2, 0, Math.PI * 0.55), mat(cabelo)), 0, 0.3, -0.02);
+    hat.traverse((o) => { o.castShadow = true; });
+    cabeca.add(hat);
+    torso.add(cabeca);
+
+    // braços (ombro > cotovelo) e pernas (quadril > joelho)
+    const lado = (s) => {
+        const mao = esfera(0.075, pele);
+        const cot = membro(BRACO, 0.065, roupa, mao); cot.position.y = -BRACO;
+        const ombro = grupo(); ombro.position.set(s * 0.34, 0.54, 0);
+        const sup = membro(BRACO, 0.07, roupa); ombro.add(sup); ombro.add(cot);
+        torso.add(ombro);
+        const sapato = em(caixa(0.16, 0.1, 0.26, '#222428', 0.04), 0, -PERNA - 0.03, 0.05);
+        const joelho = membro(PERNA, 0.075, calca); joelho.add(sapato); joelho.position.y = -PERNA;
+        const coxa = grupo(); coxa.position.set(s * 0.14, 0, 0);
+        coxa.add(membro(PERNA, 0.085, calca)); coxa.add(joelho);
+        quadril.add(coxa);
+        return { ombro, cot, coxa, joelho };
+    };
+    const E = lado(-1), D = lado(1);
+    raiz.add(quadril);
+    raiz.scale.setScalar(escala);
+    const p = { obj: raiz, quadril, torso, cabeca, olhos, boca, bracoE: E, bracoD: D, brancoY: quadril.position.y, escala };
+    raiz.userData.personagem = p;
+    raiz.userData.api = { animar: (nome, t, op) => animar(p, nome, t, op), falar: (v) => falar(p, v) };
+    return raiz;
+}
+
+/** Volta tudo para a pose neutra (as animações escrevem por cima). */
+export function zerar(p) {
+    p.quadril.position.set(0, p.brancoY, 0); p.quadril.rotation.set(0, 0, 0);
+    p.torso.rotation.set(0, 0, 0); p.cabeca.rotation.set(0, 0, 0);
+    for (const b of [p.bracoE, p.bracoD]) { b.ombro.rotation.set(0, 0, 0); b.cot.rotation.set(0, 0, 0); b.coxa.rotation.set(0, 0, 0); b.joelho.rotation.set(0, 0, 0); }
+    p.bracoE.ombro.rotation.z = 0.12; p.bracoD.ombro.rotation.z = -0.12;
+    p.boca.scale.set(1, 0.12, 0.4);
+}
+
+/** Boca aberta de 0 a 1; as pálpebras piscam sozinhas. */
+export function falar(p, v) {
+    p.boca.scale.set(1 + v * 0.1, 0.12 + v * 0.9, 0.4 + v * 0.3);
+}
+
+import { ANIMACOES, piscar } from './animacoes.js';
+
+/** Escreve a pose `nome` no tempo `t` (s). `op`: { vel, forca, boca }. */
+export function animar(p, nome, t, op = {}) {
+    zerar(p);
+    (ANIMACOES[nome] || ANIMACOES.parado)(p, t, op);
+    const pisca = piscar(t);
+    p.olhos.forEach((o) => o.scale.set(1, pisca, 1));
+    if (op.boca != null) falar(p, op.boca);
+}

package/kits/3d/remotion/Maquete.jsx

@@ -0,0 +1,42 @@
+/* A maquete: um canvas WebGL do montador + a legenda e o título da etapa por cima. */
+import React, { useLayoutEffect, useMemo, useRef } from 'react';
+import { AbsoluteFill, useCurrentFrame, useVideoConfig } from 'remotion';
+import { THREE } from './3d/base.js';
+import { montar } from './3d/montador.js';
+
+const fonte = 'system-ui, -apple-system, "Helvetica Neue", Arial, sans-serif';
+
+export const Maquete = ({ roteiro, legenda = true }) => {
+  const f = useCurrentFrame();
+  const { fps, width, height } = useVideoConfig();
+  const canvas = useRef(null), rend = useRef(null);
+  const m = useMemo(() => montar(roteiro, { aspecto: width / height }), [roteiro, width, height]);
+  const t = f / fps;
+  useLayoutEffect(() => {
+    if (!rend.current) {
+      const r = new THREE.WebGLRenderer({ canvas: canvas.current, antialias: true, preserveDrawingBuffer: true });
+      r.setPixelRatio(1); r.setSize(width, height, false); r.shadowMap.enabled = true; r.shadowMap.type = THREE.PCFSoftShadowMap;
+      r.toneMapping = THREE.ACESFilmicToneMapping; r.toneMappingExposure = 1.05; rend.current = r;
+    }
+    m.atualizar(t); rend.current.render(m.cena, m.camera);
+  }, [f, m]);
+  const { i, e, local } = m.etapaEm(t);
+  const entra = Math.min(1, local / 0.5), sai = Math.min(1, (e.dur - local) / 0.35);
+  const fade = (i === 0 ? 1 : Math.min(1, local / 0.2)) * (i === m.etapas.length - 1 ? 1 : Math.min(1, (e.dur - local) / 0.2) ) ;
+  return (
+    <AbsoluteFill style={{ background: '#8fd0ff' }}>
+      <canvas ref={canvas} width={width} height={height} style={{ width, height, opacity: 0.25 + 0.75 * fade }} />
+      {legenda && (
+        <>
+          <div style={{ position: 'absolute', left: 60, top: 130, display: 'flex', gap: 14, alignItems: 'center', opacity: entra, transform: `translateY(${(1 - entra) * -30}px)` }}>
+            {roteiro.modo !== 'dialogo' && <div style={{ background: '#ffb703', color: '#1c1c1c', font: `900 46px/1 ${fonte}`, padding: '14px 22px', borderRadius: 18, boxShadow: '0 8px 0 #c98400' }}>{i + 1}/{m.etapas.length}</div>}
+            <div style={{ background: 'rgba(255,255,255,0.94)', color: '#16324f', font: `800 50px/1 ${fonte}`, padding: '14px 26px', borderRadius: 18, boxShadow: '0 8px 0 rgba(0,0,0,0.18)' }}>{e.titulo}</div>
+          </div>
+          <div style={{ position: 'absolute', left: 60, right: 60, bottom: 250, textAlign: 'center', opacity: Math.min(entra * 2, sai * 2, 1) }}>
+            <span style={{ display: 'inline-block', background: 'rgba(17,24,39,0.82)', color: '#fff', font: `800 56px/1.22 ${fonte}`, padding: '22px 34px', borderRadius: 26 }}>{e.legenda}</span>
+          </div>
+        </>
+      )}
+    </AbsoluteFill>
+  );
+};

package/kits/3d/remotion/Root.jsx

@@ -0,0 +1,10 @@
+/* Composição Remotion da maquete 3D. O render só chama montador.atualizar(t) e fotografa. */
+import React from 'react';
+import { Composition, registerRoot } from 'remotion';
+import { Maquete } from './Maquete';
+
+const meta = ({ props }) => ({ durationInFrames: Math.max(1, props.n || 30), fps: props.fps || 30, width: props.w || 1080, height: props.h || 1920 });
+
+registerRoot(() => (
+  <Composition id="Maquete" component={Maquete} durationInFrames={30} fps={30} width={1080} height={1920} defaultProps={{ n: 30, fps: 30, w: 1080, h: 1920, roteiro: { etapas: [] } }} calculateMetadata={meta} />
+));

package/kits/3d/render.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/* render.mjs — roteiro de maquete (.json ou .mjs que exporta `roteiro`) → MP4.
+ *
+ *   node kits/3d/render.mjs roteiro.mjs saida.mp4 [--audio voz.mp3 --partes voz.json]
+ *        [--fps 30] [--quadros 10,200,900 --pasta-quadros dir]   (só fotografa esses quadros)
+ *
+ * Monta um projeto Remotion descartável em ~/.primocode/cache/maquete3d (três.js
+ * vem da base compartilhada do Estúdio), renderiza com WebGL (ANGLE) e, se vier voz,
+ * põe cada trecho no começo da sua etapa (etapa.voz = {de, ate} no arquivo de voz). */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+const AQUI = path.dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const pos = args.filter((a, i) => !a.startsWith('--') && !(args[i - 1] || '').startsWith('--'));
+const opt = (n, d) => { const i = args.indexOf('--' + n); return i >= 0 ? args[i + 1] : d; };
+if (pos.length < 2) { console.error('uso: render.mjs roteiro saida.mp4 [--audio x.mp3 --partes x.json] [--quadros 1,2,3]'); process.exit(2); }
+
+const mod = pos[0].endsWith('.json') ? { roteiro: JSON.parse(fs.readFileSync(pos[0], 'utf8')) } : await import(pathToFileURL(path.resolve(pos[0])).href);
+const roteiro = mod.roteiro || mod.default;
+const fps = Number(opt('fps', 30)), w = Number(opt('w', 1080)), h = Number(opt('h', 1920));
+const dur = roteiro.etapas.reduce((s, e) => s + e.dur, 0), n = Math.round(dur * fps);
+
+const raiz = path.join(os.homedir(), '.primocode', 'cache', 'maquete3d');
+const base = path.join(os.homedir(), '.primocode', 'studio', 'remotion-base', 'node_modules');
+if (!fs.existsSync(path.join(base, 'three'))) { console.error('falta a base do Estúdio (~/.primocode/studio/remotion-base): rode o Estúdio 3D uma vez'); process.exit(1); }
+fs.rmSync(path.join(raiz, 'src'), { recursive: true, force: true });
+fs.mkdirSync(path.join(raiz, 'src', '3d'), { recursive: true });
+for (const f of fs.readdirSync(AQUI).filter((x) => x.endsWith('.js'))) fs.copyFileSync(path.join(AQUI, f), path.join(raiz, 'src', '3d', f));
+for (const f of fs.readdirSync(path.join(AQUI, 'remotion'))) fs.copyFileSync(path.join(AQUI, 'remotion', f), path.join(raiz, 'src', f));
+fs.writeFileSync(path.join(raiz, 'package.json'), JSON.stringify({ name: 'maquete3d', private: true, type: 'module' }));
+if (!fs.existsSync(path.join(raiz, 'node_modules'))) fs.symlinkSync(base, path.join(raiz, 'node_modules'), 'dir');
+const props = path.join(raiz, 'props.json');
+fs.writeFileSync(props, JSON.stringify({ roteiro, n, fps, w, h }));
+
+const rm = (extra) => spawnSync('npx', ['remotion', ...extra, `--props=${props}`, '--gl=angle', '--log=error', '--timeout=180000'], { cwd: raiz, stdio: 'inherit' });
+const quadros = opt('quadros');
+if (quadros) {
+    const pasta = path.resolve(opt('pasta-quadros', '.')); fs.mkdirSync(pasta, { recursive: true });
+    for (const q of quadros.split(',')) if (rm(['still', 'src/Root.jsx', 'Maquete', path.join(pasta, `q${String(q).padStart(5, '0')}.png`), `--frame=${q}`]).status) process.exit(1);
+    process.exit(0);
+}
+const saida = path.resolve(pos[1]), mudo = saida.replace(/\.mp4$/, '.mudo.mp4');
+fs.mkdirSync(path.dirname(saida), { recursive: true });
+const r = args.includes('--so-mux') && fs.existsSync(mudo) ? { status: 0 } : rm(['render', 'src/Root.jsx', 'Maquete', mudo, '--codec=h264', '--crf=16', '--image-format=jpeg', '--jpeg-quality=92', `--concurrency=${Math.max(1, os.cpus().length - 2)}`]);
+if (r.status) process.exit(r.status);
+
+const audio = opt('audio'), partes = opt('partes');
+if (audio && args.includes('--audio-pronto')) {   // a voz já está na linha do tempo do vídeo (diálogo): só junta
+    const m = spawnSync('ffmpeg', ['-y', '-loglevel', 'error', '-i', mudo, '-i', path.resolve(audio), '-map', '0:v', '-map', '1:a', '-c:v', 'copy', '-c:a', 'aac', '-b:a', '160k', '-t', String(dur), saida], { stdio: 'inherit' });
+    if (m.status) process.exit(m.status);
+    fs.rmSync(mudo, { force: true }); console.log('ok', saida); process.exit(0);
+}
+if (!audio) { fs.renameSync(mudo, saida); console.log('ok (sem voz)', saida); process.exit(0); }
+// a saída do voz_kokoro.py traz avisos antes do JSON: vale a última linha que é JSON
+const vozes = JSON.parse(fs.readFileSync(partes, 'utf8').split('\n').filter((l) => l.startsWith('{')).pop()).partes;
+const entradas = ['-i', mudo, '-i', path.resolve(audio)], filtros = [];
+let ini = 0, k = 0;
+roteiro.etapas.forEach((e, i) => {
+    if (e.voz && vozes[i]) {
+        const de = e.voz.de ?? vozes[i].de, ate = e.voz.ate ?? vozes[i].ate, atraso = Math.round((ini + 0.3) * 1000);
+        filtros.push(`[1:a]atrim=${de}:${ate},asetpts=PTS-STARTPTS,adelay=${atraso}|${atraso}[v${k++}]`);
+    }
+    ini += e.dur;
+});
+filtros.push(`${Array.from({ length: k }, (_, i) => `[v${i}]`).join('')}amix=inputs=${k}:normalize=0[a]`);
+const m = spawnSync('ffmpeg', ['-y', '-loglevel', 'error', ...entradas, '-filter_complex', filtros.join(';'), '-map', '0:v', '-map', '[a]', '-c:v', 'copy', '-c:a', 'aac', '-b:a', '160k', '-t', String(dur), saida], { stdio: 'inherit' });
+if (m.status) process.exit(m.status);
+fs.rmSync(mudo, { force: true });
+console.log('ok', saida);

package/lib/cli/comando-api.js

@@ -4,7 +4,7 @@
  * Recebe do laço da sessão o que ele tem de vivo: a caixa (`rl`, função porque é reatribuída), `ask` e `askSecret`.
  */
 const os = require('os');
-const { c } = require('../tui/ui');
+const { c, Spinner } = require('../tui/ui');
 const api = require('../provider/api');
 const provedorLocal = require('../provider/local/provedor');
 
@@ -15,7 +15,8 @@ function criar({ rl, ask, askSecret }) {
      * Com provedor, o agente fala direto com a API da pessoa (lib/provider/local/motor.js);
      * sem, tudo segue pelo servidor como sempre. */
     async function comandoApi(rest) {
-        const P = provedorLocal.PROVEDORES;
+        const P = provedorLocal.PROVEDORES;              // o menu numerado
+        const T = provedorLocal.todos();                 // + os seus e os do catálogo (/api <id>)
         const ids = Object.keys(P);
         const arg = String(rest || '').trim();
         const atual = provedorLocal.atual();
@@ -25,16 +26,28 @@ function criar({ rl, ask, askSecret }) {
             console.log(c.ok('  De volta ao servidor do PrimoCode.') + c.muted('  (a chave foi apagada desta máquina)'));
             return;
         }
+        // /api modelos [filtro]: a lista do catálogo (a mesma do `primocode modelos`)
+        const lista = arg.match(/^(modelos|models)(?:\s+(.*))?$/i);
+        if (lista) {
+            const L = require('./modelos-lista');
+            await L.main(String(lista[2] || '').split(/\s+/).filter(Boolean).concat(['--ferramentas']));
+            console.log(c.dim('  (só os que usam ferramentas; /api modelos <filtro> --provedor <id> refina · primocode modelos mostra todos)'));
+            return;
+        }
         const trocaModelo = arg.match(/^(modelo|model)\s+(\S+)$/i);
         if (trocaModelo) {
-            if (!atual) { console.log(c.warn('  Nenhum provedor configurado. Rode /api primeiro.')); return; }
-            provedorLocal.trocarModelo(trocaModelo[2]);
-            console.log(c.ok(`  ${atual.nome} · modelo ${trocaModelo[2]}`));
+            const r = provedorLocal.escolherModelo(trocaModelo[2]);
+            if (!r.ok) { console.log(c.warn('  ' + r.erro)); return; }
+            const cap = require('../provider/catalogo').capacidades(r.atual.id, r.atual.modelo);
+            console.log(c.ok(`  ${r.atual.nome} · modelo ${r.atual.modelo}`));
+            if (r.aviso) console.log(c.warn('  ' + r.aviso));
+            if (cap && !cap.ferramentas) console.log(c.warn('  Este modelo não usa ferramentas: o PrimoCode vai só conversar, sem mexer em arquivos.'));
             return;
         }
 
         const apelido = { claude: 'claude-code', gpt: 'chatgpt', openai: 'chatgpt' }[arg.toLowerCase()];
-        let id = apelido || ids.find((k) => k === arg.toLowerCase() || P[k].nome.toLowerCase().startsWith(arg.toLowerCase()) && arg);
+        let id = apelido || ids.find((k) => k === arg.toLowerCase() || P[k].nome.toLowerCase().startsWith(arg.toLowerCase()) && arg)
+            || (arg && T[arg.toLowerCase()] ? arg.toLowerCase() : undefined);
         // A lista numerada, a pergunta e a resposta somem depois da escolha: fica só o resultado (lib/tui/entrada.js, marcar).
         let marca = null;
         const tirarLista = () => { if (marca && rl() && rl().voltarPara) rl().voltarPara(marca); marca = null; };
@@ -51,7 +64,7 @@ function criar({ rl, ask, askSecret }) {
             if (!id) { tirarLista(); console.log(c.muted('  Nada mudou.')); return; }
         }
 
-        const p = P[id];
+        const p = T[id];
         // Claude Code e Codex não pedem chave: basta a ferramenta estar instalada
         // e logada. Quem pensa é ela; quem executa é o PrimoCode.
         if (p.cli) {
@@ -66,7 +79,16 @@ function criar({ rl, ask, askSecret }) {
             console.log(c.dim(`  O ${p.nome} decide, o PrimoCode executa. /api off volta ao servidor`));
             return;
         }
-        console.log(c.muted(`  Pegue a chave em `) + c.white(p.onde));
+        // chave já no ambiente (GROQ_API_KEY etc.): não precisa colar nada
+        if (provedorLocal.chaveDoAmbiente(p)) {
+            const salvo = provedorLocal.salvar({ provedor: id, chave: '', modelo: p.modelos[0] });
+            tirarLista();
+            console.log(c.ok(`  Pronto: ${salvo.nome} · ${salvo.modelo}`) + c.muted(`  · chave de ${p.env.find((n) => process.env[n])}`));
+            console.log(c.dim('  /api modelos lista · /api modelo <provedor>/<modelo> troca · /api off volta ao servidor'));
+            return;
+        }
+        if (p.onde) console.log(c.muted(`  Pegue a chave em `) + c.white(p.onde));
+        else if (p.env && p.env[0]) console.log(c.muted(`  Ou defina ${p.env[0]} no ambiente e rode /api ${id} de novo.`));
         const chave = String(await askSecret(`  ${c.brand('?')} Cole a chave do ${p.nome} (não aparece na tela): `)).trim();
         if (!chave) { tirarLista(); console.log(c.muted('  Nada mudou.')); return; }
         const sp = new Spinner('conferindo a chave').start();

package/lib/cli/modelos-lista.js

@@ -0,0 +1,58 @@
+'use strict';
+/**
+ * modelos-lista.js — a lista de modelos do catálogo (models.dev) para a CLI e o app.
+ *   primocode modelos [filtro] [--provedor <id>] [--ferramentas] [--gratis] [--atualizar] [--json]
+ *   /api modelos [filtro]    (dentro da sessão)
+ * Mesmo papel do `opencode models`: uma linha por modelo, "provedor/modelo".
+ */
+const catalogo = require('../provider/catalogo');
+const provedorLocal = require('../provider/local/provedor');
+
+const k = (n) => (n >= 1e6 ? `${+(n / 1e6).toFixed(1)}M` : n >= 1000 ? `${Math.round(n / 1000)}k` : n ? String(n) : '?');
+
+/** "provedor/modelo  ctx 128k  ferramentas visão  grátis" — o que decide se serve para o agente. */
+function linha(m, { atual = '' } = {}) {
+    const caps = [m.ferr ? 'ferramentas' : '', m.visao ? 'visão' : '', m.raciocinio ? 'raciocínio' : ''].filter(Boolean).join(' ') || '-';
+    const preco = m.custoIn === null || m.custoOut === null ? '?' : (m.custoIn === 0 && m.custoOut === 0 ? 'grátis' : `$${m.custoIn}/$${m.custoOut}`);
+    return `${m.ref === atual ? '*' : ' '} ${m.ref.padEnd(52)} ${('ctx ' + k(m.ctx)).padEnd(9)} ${caps.padEnd(30)} ${preco}`;
+}
+
+function lerArgs(args) {
+    const o = { filtro: [], provedor: '', ferramentas: false, gratis: false, atualizar: false, json: false };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--provedor' || a === '-p') o.provedor = args[++i] || '';
+        else if (a === '--ferramentas') o.ferramentas = true;
+        else if (a === '--gratis') o.gratis = true;
+        else if (a === '--atualizar') o.atualizar = true;
+        else if (a === '--json') o.json = true;
+        else o.filtro.push(a);
+    }
+    o.filtro = o.filtro.join(' ');
+    return o;
+}
+
+/** Modelos de um provedor, para a tela do app (sem o resto do catálogo). */
+function doProvedor(id) {
+    return catalogo.listar({ provedor: id }).map((m) => ({ id: m.id, nome: m.nome, ferr: m.ferr, visao: m.visao, ctx: m.ctx }));
+}
+
+async function main(args = [], { saida = (t) => console.log(t) } = {}) {
+    const o = lerArgs(args);
+    // sem cache ainda (ou pedido): tenta a rede; offline, o embutido responde
+    if (o.atualizar || catalogo.carregarSync().origem !== 'cache') {
+        const r = await catalogo.atualizar({ forcar: o.atualizar });
+        if (o.atualizar && !r.ok) saida(`  não consegui atualizar (${r.erro}); usando ${r.origem}.`);
+    }
+    const cat = catalogo.carregarSync();
+    const lista = catalogo.listar({ catalogo: cat, provedor: o.provedor, filtro: o.filtro, soFerramentas: o.ferramentas, soGratis: o.gratis });
+    if (o.json) { saida(JSON.stringify(lista)); return 0; }
+    const a = provedorLocal.atual();
+    const atual = a ? `${a.id}/${a.modelo}` : '';
+    lista.forEach((m) => saida(linha(m, { atual })));
+    const nProv = new Set(lista.map((m) => m.provedor)).size;
+    saida(`\n  ${lista.length} modelos de ${nProv} provedores (catálogo: ${cat.origem}). Escolher: /api modelo <provedor>/<modelo>`);
+    return 0;
+}
+
+module.exports = { main, linha, lerArgs, doProvedor };

package/lib/cli/sessao.js

@@ -35,6 +35,7 @@ const memoria = require('../session/memoria-conversa');
 const registro = require('../registro');
 const permissao = require('../permission/permissao');
 const perigo = require('../permission/perigo');
+const semPerguntar = require('../permission/sem-perguntar');
 const skills = require('../skill/skills');
 const checkpoint = require('../session/checkpoint');
 const comandosLib = require('./comandos');
@@ -159,6 +160,7 @@ ${c.bold('Comandos')}
 
 ${linhas.join('\n')}
   ${c.brand('-p')} "pedido"          modo script: sem tela, aceita stdin e --output-format json
+  ${c.brand('--dangerously-skip-permissions')}  (ou ${c.brand('--yolo')}) não pede nenhuma confirmação
 
 ${c.dim('digite / pra ver todos')}
 `;
@@ -170,6 +172,7 @@ ${c.bold('Comandos')} ${c.dim('· os nomes em português continuam valendo (/des
 
 ${linhasDosGrupos().join('\n')}
   ${c.brand('-p')} "pedido"          modo script: sem tela, aceita stdin e --output-format json
+  ${c.brand('--dangerously-skip-permissions')}  (ou ${c.brand('--yolo')}) não pede nenhuma confirmação
 
 ${c.bold('Modos')}
   ${c.warn('Primo Code')}  ${c.muted('Agente completo — cria arquivos, roda comandos, abre o navegador')}
@@ -983,6 +986,7 @@ async function talvezTrocarDePasta(userText) {
 /* A pergunta da troca. Enter sozinho é NÃO: trocar muda onde os arquivos
    nascem, e o padrão de quem apertou Enter sem ler não pode ser esse. */
 async function perguntarTroca(caminho, motivo = '') {
+    if (semPerguntar.ativo()) return true;   // --yolo
     if (motivo) console.log('  ' + c.muted(motivo));
     const dito = String(await ask(`${c.brand('?')} Trabalhar em ${c.white(shortPath(caminho))} a partir de agora? ${c.muted('(s/N)')} `))
         .trim().toLowerCase().replace(/[.!?,;:…]+/g, ' ').trim();
@@ -1002,6 +1006,7 @@ function trocarPara(caminho, origem, porque) {
 /* Servidor MCP do .mcp.json do PROJETO: roda comando na máquina, então pergunta
    mesmo no auto (lib/mcp/mcp.js lembra o sim por projeto + configuração). */
 require('../mcp/mcp.js').usarPerguntador(async ({ nome, resumo }) => {
+    if (semPerguntar.ativo()) return true;   // --yolo
     if (state.semTerminal) return false;
     console.log('');
     console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white(`O .mcp.json deste projeto quer rodar o servidor "${nome}".`)));
@@ -1501,6 +1506,8 @@ async function enviarPedido(userText) {
                 history: i === 0 ? memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()) : [],
                 projectDir: plan.dir,
                 projectName: plan.name || state.currentProject,
+                // o Estúdio aberto: o provedor com limite de TPM manda só motion + arquivos (lib/provider/local/recorte.js)
+                modo: state.estudioAtivo ? 'estudio' : undefined,
                 // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
                 // não é motivo para criar pasta de projeto.
                 ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
@@ -3757,6 +3764,10 @@ function conferirServidor() {
 }
 
 async function main() {
+    /* --dangerously-skip-permissions / --yolo: liga PRIMOCODE_SEM_PERGUNTAR=1 e sai do argv (lib/permission/sem-perguntar.js). */
+    if (semPerguntar.consumir(process.argv)) {
+        console.error(c.warn('  ' + semPerguntar.AVISO));   // stderr: não suja a saída JSON do -p
+    }
     /* `primocode autoteste|preview|review|pesquisar`: entradas sem sessão (lib/cli/subcomandos.js). */
     if (require('./subcomandos.js').NOMES.includes(process.argv[2])) {
         process.exit(await require('./subcomandos.js').main(process.argv[2], process.argv.slice(3)));

package/lib/cli/subcomandos.js

@@ -1,6 +1,6 @@
 /**
  * subcomandos.js — as entradas `primocode <nome> ...` que saem ANTES da sessão (sem tela):
- *   autoteste · preview · review · pesquisar
+ *   autoteste · preview · review · pesquisar · modelos
  * Cada uma chama o módulo de lib/plugin/ ou lib/cli/. O bin só faz `if (NOMES.includes(argv[2]))`.
  */
 'use strict';
@@ -8,7 +8,7 @@
 const path = require('path');
 const { sh } = require('./util.js');
 
-const NOMES = ['autoteste', 'preview', 'review', 'pesquisar'];
+const NOMES = ['autoteste', 'preview', 'review', 'pesquisar', 'modelos'];
 
 async function autoteste(args) {
     const A = require('../plugin/autoteste.js');
@@ -28,6 +28,7 @@ async function main(nome, args) {
     if (nome === 'preview') return require('../plugin/preview-cli.js').main(args);
     if (nome === 'review') return require('./review.js').main(args);
     if (nome === 'pesquisar') return require('../plugin/pesquisar.js').main(args);
+    if (nome === 'modelos') return require('./modelos-lista.js').main(args);
     return 1;
 }
 

package/lib/outra-pasta.js

@@ -149,7 +149,7 @@ async function pedirTroca(args, { atual = '', subagent = false, trocar = null, r
         return { ok: false, error: 'trocar de pasta precisa do sim do usuário, e não há ninguém para responder neste modo. '
             + 'Leia lá se precisar e diga a ele o caminho para usar /dir.' };
     }
-    const r = await trocar({ caminho: destino, motivo });
+    const r = await trocar({ caminho: destino, motivo, semPerguntar: require('./permission/sem-perguntar.js').ativo() });
     if (!r || !r.ok) {
         return { ok: false, recusado: true,
             error: (r && r.error) || 'o usuário NÃO quis trocar de pasta. Continue na atual; ler a outra pasta NÃO foi liberado.' };