primocode 10.0.9 → 10.2.0

package/lib/video/zoom.js

@@ -0,0 +1,275 @@
+/**
+ * zoom.js — o zoom que segue o cursor numa gravação de tela.
+ *
+ * Três peças, como conta pura e testável sem vídeo nenhum:
+ *
+ *   · os FOCOS: o clique, quando há registro dele; sem clique, o lugar onde
+ *     o movimento PARA (o cursor anda, assenta e alguém vai clicar ali);
+ *   · os TRECHOS: focos próximos no tempo viram um zoom só; uma pausa longa
+ *     ou um salto para longe (com tempo de sobra) fecham o zoom e abrem outro;
+ *   · a CÂMERA: dentro do trecho ela fica parada enquanto o cursor anda numa
+ *     zona morta no meio da vista, e só anda quando ele sai dali — puxada por
+ *     uma mola criticamente amortecida, sem tremer e sem passar do ponto.
+ *
+ * Reimplementação independente da ideia (curva, regra de clique e mola):
+ * nenhuma linha vem de outro projeto.
+ *
+ * Saída: keyframes de zoom e do FOCO do zoom (fx, fy: 0–1 do clipe), que o
+ * filters.js já sabe desenhar no zoompan.
+ */
+
+'use strict';
+
+const { spawn } = require('child_process');
+
+const lim = (v, a, b) => Math.max(a, Math.min(b, v));
+
+// ── medir: onde a tela mexeu (quando ninguém gravou o cursor) ────────────
+
+/**
+ * Quadros cinza (Uint8Array w*h, um por amostra) → [{t, x, y, move}].
+ * x,y = centro do que mudou desde o quadro anterior (o cursor, numa tela
+ * parada). Mudança grande demais (rolagem, troca de janela) não é cursor.
+ */
+function movimento(quadros, w, h, fps, { limiar = 24, maxFracao = 0.2 } = {}) {
+    const out = [];
+    for (let i = 1; i < quadros.length; i++) {
+        const a = quadros[i - 1];
+        const b = quadros[i];
+        let n = 0;
+        let sx = 0;
+        let sy = 0;
+        for (let k = 0; k < w * h; k++) {
+            if (Math.abs(a[k] - b[k]) > limiar) { n++; sx += k % w; sy += Math.floor(k / w); }
+        }
+        const t = i / fps;
+        if (n < 2 || n > maxFracao * w * h) out.push({ t, x: null, y: null, move: false });
+        else out.push({ t, x: (sx / n + 0.5) / w, y: (sy / n + 0.5) / h, move: true });
+    }
+    return out;
+}
+
+/** Trilha de cursor [{t,x,y,click?}] → amostras com `move` (andou desde a anterior). */
+function doCursor(cursor, { parado = 0.004 } = {}) {
+    const c = cursor.filter((p) => Number.isFinite(p.t) && Number.isFinite(p.x) && Number.isFinite(p.y)).sort((a, b) => a.t - b.t);
+    return c.map((p, i) => ({ ...p, move: i > 0 && Math.hypot(p.x - c[i - 1].x, p.y - c[i - 1].y) > parado }));
+}
+
+/**
+ * Os focos: os cliques, se houver; senão, onde o movimento para — andou por
+ * `minAndou` s e depois ficou parado por `minParado` s. [{t, x, y}].
+ */
+function focos(amostras, { minAndou = 0.15, minParado = 0.3 } = {}) {
+    const cliques = amostras.filter((a) => a.click);
+    if (cliques.length) return cliques.map(({ t, x, y }) => ({ t, x, y }));
+    const out = [];
+    let ini = null;
+    let ult = null;
+    for (const a of amostras) {
+        if (a.move) { if (ini === null) ini = a.t; ult = a; continue; }
+        if (ult && ini !== null && ult.t - ini >= minAndou - 1e-9 && a.t - ult.t >= minParado - 1e-9) {
+            out.push({ t: ult.t, x: ult.x, y: ult.y });
+            ini = null;
+            ult = null;
+        }
+    }
+    return out;
+}
+
+// ── os trechos e a câmera ────────────────────────────────────────────────
+
+/**
+ * Focos (t em QUADROS do clipe) → trechos [{de, ate, focos}]. Fecha o trecho
+ * na pausa maior que `juntar` ou no salto maior que `longe` quando há tempo
+ * de sair e voltar (2 rampas); salto rápido fica no mesmo trecho e vira pan.
+ */
+function trechos(fs, { fps, juntar = 2.5, longe = 0.35, antes = 0.4, segura = 1.2, rampa = 0.5 } = {}) {
+    const out = [];
+    const R = rampa * fps;
+    for (const f of [...fs].sort((a, b) => a.t - b.t)) {
+        const u = out[out.length - 1];
+        const ult = u && u.focos[u.focos.length - 1];
+        const gap = ult ? f.t - ult.t : Infinity;
+        if (u && gap <= juntar * fps && !(Math.hypot(f.x - ult.x, f.y - ult.y) > longe && gap > 2 * R + segura * fps)) { u.focos.push(f); continue; }
+        out.push({ focos: [f] });
+    }
+    for (const s of out) {
+        s.de = Math.max(0, Math.round(s.focos[0].t - antes * fps - R));
+        s.ate = Math.round(s.focos[s.focos.length - 1].t + segura * fps);
+    }
+    // Um trecho não invade a saída do anterior.
+    for (let i = 1; i < out.length; i++) out[i - 1].ate = Math.max(out[i - 1].focos[out[i - 1].focos.length - 1].t, Math.min(out[i - 1].ate, out[i].de - R));
+    return out;
+}
+
+/**
+ * A câmera, quadro a quadro: [{z, x, y}] para `dur` quadros. `pos(f)` = onde
+ * o cursor está no quadro f (ou null). Zona morta = fração da meia-vista.
+ */
+function camera(dur, ts, pos, { fps, zoom = 1.8, rampa = 0.5, zonaMorta = 0.45, hz = 1.4 } = {}) {
+    const R = Math.max(1, Math.round(rampa * fps));
+    const out = [];
+    const w = 2 * Math.PI * hz;
+    const dt = 1 / fps;
+    let cam = { x: 0.5, y: 0.5 };
+    let vel = { x: 0, y: 0 };
+    let alvo = { ...cam };
+    let s = null;
+    for (let f = 0; f < dur; f++) {
+        const novo = ts.find((t) => f >= t.de && f < t.ate + R);
+        if (novo !== s) {
+            s = novo;
+            if (s) { cam = { x: s.focos[0].x, y: s.focos[0].y }; alvo = { ...cam }; vel = { x: 0, y: 0 }; }
+        }
+        let z = 1;
+        if (s) {
+            const p = f < s.de + R ? (f - s.de) / R : f >= s.ate ? 1 - (f - s.ate) / R : 1;
+            z = 1 + (zoom - 1) * p * p * (3 - 2 * p);
+            // Segue o cursor só entre o primeiro e o último foco: antes, mira o foco; depois, segura.
+            const c = f >= s.focos[0].t && f <= s.focos[s.focos.length - 1].t ? pos(f) : null;
+            const meia = 0.5 / zoom;
+            if (c) {
+                for (const k of ['x', 'y']) {
+                    const d = c[k] - alvo[k];
+                    const zm = zonaMorta * meia;
+                    if (Math.abs(d) > zm) alvo[k] = c[k] - Math.sign(d) * zm;
+                    alvo[k] = lim(alvo[k], meia, 1 - meia);
+                }
+            }
+            for (const k of ['x', 'y']) {
+                vel[k] += (w * w * (alvo[k] - cam[k]) - 2 * w * vel[k]) * dt;   // mola crítica: chega sem passar
+                cam[k] += vel[k] * dt;
+            }
+        }
+        const meiaZ = 0.5 / z;
+        out.push({ z, x: lim(cam.x, meiaZ, 1 - meiaZ), y: lim(cam.y, meiaZ, 1 - meiaZ) });
+    }
+    return out;
+}
+
+/** Ramer–Douglas–Peucker numa série: os quadros que bastam para a reta não errar mais que `tol`. */
+function enxugar(v, tol) {
+    const manter = new Set([0, v.length - 1]);
+    const pilha = [[0, v.length - 1]];
+    while (pilha.length) {
+        const [a, b] = pilha.pop();
+        let pior = -1;
+        let max = tol;
+        for (let i = a + 1; i < b; i++) {
+            const d = Math.abs(v[i] - (v[a] + ((v[b] - v[a]) * (i - a)) / (b - a)));
+            if (d > max) { max = d; pior = i; }
+        }
+        if (pior >= 0) { manter.add(pior); pilha.push([a, pior], [pior, b]); }
+    }
+    return [...manter].sort((x, y) => x - y);
+}
+
+/** Câmera → keyframes {zoom, fx, fy} em quadros do clipe ({frame, value, interp}). */
+function keyframes(cam, { tol = 0.002 } = {}) {
+    const out = {};
+    for (const [prop, k] of [['zoom', 'z'], ['fx', 'x'], ['fy', 'y']]) {
+        const v = cam.map((c) => c[k]);
+        out[prop] = enxugar(v, prop === 'zoom' ? 0.01 : tol).map((f) => ({ frame: f, value: Math.round(v[f] * 10000) / 10000, interp: 'linear' }));
+    }
+    return out;
+}
+
+/**
+ * Tudo junto. `amostras` com t em QUADROS do clipe e x,y em 0–1 do clipe.
+ * Devolve {focos, trechos, cam, keys}.
+ */
+function planejar(amostras, dur, opts) {
+    const fs = focos(amostras.map((a) => ({ ...a, t: a.t / opts.fps })), opts).map((f) => ({ ...f, t: Math.round(f.t * opts.fps) }));
+    const ts = trechos(fs, opts);
+    const comPos = amostras.filter((a) => a.x !== null && a.x !== undefined);
+    let i = 0;
+    const pos = (f) => {   // a última posição conhecida até f (f só cresce)
+        while (i + 1 < comPos.length && comPos[i + 1].t <= f) i++;
+        return comPos[i] && comPos[i].t <= f ? comPos[i] : null;
+    };
+    const cam = camera(dur, ts, pos, opts);
+    return { focos: fs, trechos: ts, cam, keys: keyframes(cam) };
+}
+
+// ── o ffmpeg mede ────────────────────────────────────────────────────────
+
+/** Quadros cinza pequenos da origem [de, ate) segundos, a `fps` por segundo. */
+function quadrosCinza(arquivo, de, ate, { fps = 15, w = 160, h = 90 } = {}) {
+    const video = require('../estudio/video.js');
+    return new Promise((resolve, reject) => {
+        const p = spawn(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', '-ss', String(de), '-t', String(ate - de), '-i', arquivo,
+            '-vf', `fps=${fps},scale=${w}:${h}:flags=area,format=gray`, '-f', 'rawvideo', '-']);
+        const partes = [];
+        p.stdout.on('data', (d) => partes.push(d));
+        p.on('error', reject);
+        p.on('close', (code) => {
+            if (code !== 0) return reject(new Error('não consegui ler os quadros'));
+            const b = Buffer.concat(partes);
+            const out = [];
+            for (let k = 0; k + w * h <= b.length; k += w * h) out.push(b.subarray(k, k + w * h));
+            resolve(out);
+        });
+    });
+}
+
+// ── a operação do editor ─────────────────────────────────────────────────
+
+/** Ponto da ORIGEM (0–1) → ponto do clipe (0–1), depois do encaixe (cover/contain). */
+function paraClipe(tl, clip, asset, x, y) {
+    if (clip.fit === 'stretch') return { x, y };
+    const bw = clip.transform.w * tl.width;
+    const bh = clip.transform.h * tl.height;
+    const aw = asset.width || bw;
+    const ah = asset.height || bh;
+    const esc = clip.fit === 'contain' ? Math.min(bw / aw, bh / ah) : Math.max(bw / aw, bh / ah);
+    return { x: lim(0.5 + ((x - 0.5) * aw * esc) / bw, 0, 1), y: lim(0.5 + ((y - 0.5) * ah * esc) / bh, 0, 1) };
+}
+
+const OPS = {
+    auto_zoom: {
+        uso: 'auto_zoom {id?,zoom?:1.8,cursor?:[{t(s da origem),x,y(0–1),click?}]|cursorFile?,deadZone?:0.45,remove?} — gravação de tela: entra no clique (sem cursor: onde o movimento para), segue com zona morta e mola, sai na pausa',
+        async run(ctx, a) {
+            const T = require('./timeline.js');
+            const E = require('./edits.js');
+            const { mutar } = require('./ops.js');
+            if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."}');
+            const primeiro = T.todosOsClipes(ctx.tl).find((x) => x.clip.type === 'video');
+            if (!a.id && !primeiro) throw T.erro('não há clipe de vídeo');
+            const { clip } = T.achar(ctx.tl, a.id || primeiro.clip.id);
+            if (a.remove) return mutar(ctx, 'auto_zoom', (tl) => { for (const p of ['zoom', 'fx', 'fy']) E.keyframes(tl, clip.id, p, []); });
+            const asset = ctx.tl.assets[clip.asset];
+            const fps = ctx.tl.fps;
+            const { de, ate } = T.janelaOrigem(ctx.tl, clip);
+            let cru;
+            let fonte;
+            if (a.cursor || a.cursorFile) {
+                cru = doCursor(a.cursor || JSON.parse(require('fs').readFileSync(a.cursorFile, 'utf8')));
+                fonte = cru.some((x) => x.click) ? 'cliques' : 'cursor';
+            } else {
+                const mfps = 15;
+                const h = 2 * Math.round((80 * (asset.height || 9)) / (asset.width || 16));
+                cru = movimento(await quadrosCinza(asset.path, de, ate, { fps: mfps, w: 160, h }), 160, h, mfps).map((x) => ({ ...x, t: x.t + de }));
+                fonte = 'movimento';
+            }
+            const amostras = [];
+            for (const x of cru) {
+                const f = T.origemParaQuadro(ctx.tl, clip, x.t);
+                if (f === null) continue;
+                const p = x.x === null ? { x: null, y: null } : paraClipe(ctx.tl, clip, asset, x.x, x.y);
+                amostras.push({ ...x, ...p, t: f - clip.startFrame });
+            }
+            const pl = planejar(amostras, clip.durationFrames, { fps, zoom: lim(Number(a.zoom) || 1.8, 1.1, 3), zonaMorta: a.deadZone ?? 0.45 });
+            const zooms = pl.trechos.map((t) => [t.de + clip.startFrame, t.ate + clip.startFrame]);
+            if (!pl.focos.length) return { ok: true, nada: true, fonte, focos: 0, aviso: 'nenhum clique nem parada do cursor: nada para aproximar' };
+            return mutar(ctx, 'auto_zoom', (tl) => {
+                for (const [p, ks] of Object.entries(pl.keys)) E.keyframes(tl, clip.id, p, ks.map((k) => ({ ...k, frame: k.frame + clip.startFrame })));
+                return { fonte, focos: pl.focos.length, zooms };
+            });
+        },
+    },
+};
+
+// Sem linha de exemplo: a ajuda principal cabe em 60 linhas, e o `uso` já mostra a forma.
+const EX = {};
+
+module.exports = { movimento, doCursor, focos, trechos, camera, enxugar, keyframes, planejar, quadrosCinza, paraClipe, OPS, EX };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "10.0.9",
+  "version": "10.2.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js && node test/gerativo.test.js && node test/hibrido.test.js && node test/mcp.test.js && node test/personas.test.js && node test/efeitos.test.js && node test/auto.test.js && node test/colar.test.js && node test/orquestra.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js && node test/gerativo.test.js && node test/hibrido.test.js && node test/batida.test.js && node test/revisor.test.js && node test/biblioteca.test.js && node test/mcp.test.js && node test/personas.test.js && node test/efeitos.test.js && node test/auto.test.js && node test/colar.test.js && node test/orquestra.test.js && node test/shell-limpo.test.js && node test/editar-remotion.test.js && node test/variacao3d.test.js && node test/portao-skill.test.js && node test/clones.test.js && node test/kokoro.test.js && node test/fluido.test.js && node test/zoom.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/skills/escrever-em-portugues/SKILL.md

@@ -25,4 +25,7 @@ superlativo sem número.
 Número concreto vence adjetivo: "responde em 2 segundos" vale mais que
 "ultrarrápido".
 
+**Revisando um texto pronto**: aponte o trecho que soa errado e reescreva só
+ele. O resto, que já funciona, fica como está.
+
 Não use emoji para dar emoção a um texto que não tem nenhuma.

package/skills/interface-revisada/SKILL.md

@@ -12,7 +12,8 @@ a correção. Primeiro o que impede alguém de usar; acabamento vai no fim.
 - O que é clicável é `button` ou `a`, com hover, estado pressionado e foco
   visível (`:focus-visible`).
 - Alvo de toque de pelo menos 44×44px. Nada importante escondido só no hover.
-- Ação que demora mostra que está trabalhando e não pode ser enviada duas vezes.
+- Todo clique responde em até 200 ms. Ação que demora mostra que está
+  trabalhando e não pode ser enviada duas vezes.
 - Ação que apaga pede confirmação ou oferece desfazer.
 - O endereço guarda o estado (aba, filtro, página): o voltar do navegador e o
   link compartilhado levam ao mesmo lugar.
@@ -32,6 +33,7 @@ novo) e cheio (texto longo quebra ou termina em `…`; mil itens não travam).
 **Layout**
 - De 360px a 1440px sem rolagem para o lado; respeita a área segura do celular
   (`env(safe-area-inset-bottom)`).
+- Tela cheia é `100dvh`, nunca `100vh` (no celular, `vh` some sob a barra).
 - Imagem com `width`/`height` ou `aspect-ratio`, para a página não pular.
 - Número em coluna com `tabular-nums`; título com `text-wrap: balance`.
 
@@ -43,5 +45,9 @@ rolagem acompanham) e contraste de 4.5:1 nos dois temas. Animação só em
 `transform` e `opacity`, curta (150 a 300ms) e desligada em
 `prefers-reduced-motion`. Nunca `transition: all`.
 
+**Pior caso** (teste com o dado ruim): Texto enorme (`min-width: 0` e
+`overflow-wrap: anywhere`); Lista vazia; largura de 320px; Rede lenta (DevTools,
+Slow 3G); Mil itens (paginar ou virtualizar).
+
 **Feche com a contagem**: quantos impedem o uso, quantos atrapalham, quantos são
 acabamento. E conserte nessa mesma ordem.

package/skills/motion-de-primeira/SKILL.md

@@ -57,11 +57,9 @@ Em vídeo de produto, anúncio e vinheta, escreva **uma cena de 8 a 15 s** no
 - **A troca é no mesmo lugar e instante**: o foguete some onde o ícone nasce; o
   app nasce do tamanho e da COR do ícone.
 
-Por roteiro, o padrão é `hibrido` (dê `busca` em inglês por parte); `gerativo` (o motion), `vox` (explicar; dê
-`destaque` e `fonte`), `marca`, `lancamento` pelo nome; `visual` troca a peça de uma parte.
-
-Pedido de motion (ou sem referências): `estilo: "gerativo"`, só o roteiro
-(`fala`, `destaque`); `roteiro.semente` sorteia outro, `modelo3d` traz o 3D.
+Sem imagem é o padrão (foto só se pedirem). Decida `clima`, o impacto (`destaque`, ≤1 em 3 partes), o
+respiro e o `estilo` deste roteiro: `gerativo`, `fluido`, `impacto`, `vox`, `marca`, `lancamento`; vazio, gira.
+`hibrido` só com imagem pedida. Leia os avisos da revisão.
 
 ## Cor e tipo
 

package/skills/projeto-no-github/SKILL.md

@@ -27,6 +27,12 @@ Tudo pelo `gh` (GitHub CLI) e pelo `git`, rodando no terminal do projeto.
 4. `gh pr create --fill` (ou `--title` e `--body` dizendo o que e por quê).
    Diga o link do PR.
 
+**Segredo:** `.env` só existe na máquina. Nunca crie, edite ou renomeie
+`.env` pelo site do GitHub (renomear `.env.example` para `.env` lá já vazou
+chave em repositório público). O `.env.example` leva só os nomes, sem valor.
+Antes do push: `git ls-files | grep '\.env$'` tem de vir vazio. Vazou? Troque a
+chave na hora; apagar o arquivo não basta, ela fica no histórico.
+
 **Nunca** faça `push --force` em `main`, nunca apague branch dos outros, nunca
 commite `.env`. Conflito: resolva lendo os dois lados, não escolhendo um às
 cegas.

package/skills/publicar-na-internet/SKILL.md

@@ -31,6 +31,9 @@ ela quem entra na conta dela.
 **3. Confira:** abra a URL publicada com browser_open e leia a página. Só diga
 que está no ar se ela abriu com o conteúdo certo. Termine dizendo o LINK.
 
+**Link compartilhável:** `og:image` com URL absoluta (`https://.../capa.png`),
+nunca `/capa.png`; sem isso o link sai sem imagem no WhatsApp.
+
 **Nunca** publique `.env`, chave ou senha: confira se `.gitignore` e o
 `.vercelignore`/`.netlifyignore` os deixam de fora. Variáveis secretas vão no
 painel do serviço (ou `vercel env add`), não no código.

package/skills/site-com-motion/SKILL.md

@@ -26,6 +26,8 @@ tudo com a mesma duração; `transition: all`; texto piscando; nada que responda
   que acompanha o scroll (parallax, barra de progresso, imagem que cresce), use
   `animation-timeline: view()` e deixe a página parada onde isso não existe (`@supports`).
 - **Só `transform` e `opacity`.** Animar `top`, `width`, `height` ou `box-shadow` trava no celular.
+  Confira com grep: zero `transition: all` no CSS.
+- **Seção de tela cheia** usa `100dvh`, e não `100vh`, pra não ficar atrás da barra do celular.
 - **Troca de página ou de estado:** a View Transitions API (`document.startViewTransition`), com o
   caminho sem animação quando o navegador não tiver.
 - **Biblioteca só se precisar.** CSS e um pouco de JS resolvem quase tudo. Timeline longa ou texto

package/studio/voz_kokoro.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""voz_kokoro.py — a voz local, sem cota e sem servidor (Kokoro-82M, na CPU).
+
+O Gemini é a voz de gente, mas a cota grátis é pequena e às vezes o áudio
+volta cortado (medido em 25/09). O Kokoro roda nesta máquina: 11 s de áudio
+em 3,5 s, mais 4,3 s para carregar o modelo, sem corte no fim (05/10).
+
+Roda pelo `uv` (lib/estudio/kokoro.js monta o comando), com as versões
+fixadas: sem `transformers>=4.45` o uv escolhe a 4.12 e o tokenizers não
+compila; sem ESPEAK_DATA_PATH o espeak embutido aponta para uma pasta que
+não existe.
+
+Não se chama kokoro.py: a pasta do script entra no sys.path e o nome
+esconderia o pacote `kokoro` (medido em 05/10).
+
+Uso (a mesma entrada e a mesma saída do `narrar.py roteiro`):
+    voz_kokoro.py roteiro --arquivo partes.json --saida narracao.mp3 [--voz pf_dora]
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+TAXA = 24000
+RESPIRO = 0.12  # o mesmo respiro curto entre as partes do narrar.py
+
+
+def _palavras(texto, de, ate):
+    """O Kokoro em português não devolve o tempo de cada palavra: ele é
+    repartido pelo tamanho da palavra dentro da parte (melhor que nada para
+    a tipografia seguir a voz)."""
+    ws = texto.split()
+    total = sum(len(w) for w in ws) or 1
+    out, t = [], de
+    for w in ws:
+        d = (ate - de) * len(w) / total
+        out.append({"de": round(t, 3), "ate": round(t + d, 3), "texto": w})
+        t += d
+    return out
+
+
+def comando_roteiro(args):
+    import numpy as np
+    import soundfile as sf
+    from kokoro import KPipeline
+
+    partes = json.loads(Path(args.arquivo).read_text(encoding="utf-8"))
+    if not partes:
+        return {"ok": False, "error": "o roteiro veio vazio"}
+    pipe = KPipeline(lang_code="p")  # português do Brasil
+    pausa = np.zeros(int(TAXA * RESPIRO), dtype=np.float32)
+    blocos, trechos, palavras, t = [], [], [], 0.0
+    for parte in partes:
+        texto = re.sub(r"\s+", " ", str(parte.get("texto") or "")).strip()
+        if not texto:
+            trechos.append({"de": round(t, 3), "ate": round(t, 3), "palavras": []})
+            continue
+        audio = np.concatenate([np.asarray(a, dtype=np.float32) for _, _, a in pipe(texto, voice=args.voz)])
+        dur = len(audio) / TAXA
+        ws = _palavras(texto, t, t + dur)
+        palavras += ws
+        trechos.append({"de": round(t, 3), "ate": round(t + dur, 3), "palavras": ws})
+        blocos += [audio, pausa]
+        t += dur + RESPIRO
+    with tempfile.TemporaryDirectory() as tmp:
+        wav = Path(tmp) / "voz.wav"
+        sf.write(str(wav), np.concatenate(blocos), TAXA)
+        r = subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", str(wav),
+                            "-af", "loudnorm=I=-14:TP=-1.5:LRA=9", "-c:a", "libmp3lame", "-q:a", "3",
+                            str(args.saida)], capture_output=True, timeout=180)
+        if r.returncode != 0:
+            return {"ok": False, "error": (r.stderr or b"").decode("utf-8", "ignore")[-300:]}
+    return {"ok": True, "arquivo": str(args.saida), "motor": "kokoro", "voz": f"kokoro {args.voz}",
+            "segundos": round(t, 3), "partes": trechos, "palavras": palavras}
+
+
+def main():
+    p = argparse.ArgumentParser(description="Narração local do PrimoCode Studio (Kokoro)")
+    sub = p.add_subparsers(dest="comando", required=True)
+    r = sub.add_parser("roteiro")
+    r.add_argument("--arquivo", required=True)
+    r.add_argument("--saida", required=True)
+    r.add_argument("--voz", default="pm_alex")
+    args = p.parse_args()
+    try:
+        saida = comando_roteiro(args)
+    except Exception as e:  # nunca derruba a corrente: o JS passa para a próxima voz
+        saida = {"ok": False, "error": f"o kokoro falhou: {str(e)[:300]}"}
+    print(json.dumps(saida, ensure_ascii=False))
+    sys.exit(0 if saida.get("ok") else 1)
+
+
+if __name__ == "__main__":
+    main()