primocode 9.10.0 → 10.0.9

package/lib/video/ops.js

@@ -0,0 +1,347 @@
+/**
+ * ops.js — as operações do editor, uma por nome, com o texto de ajuda junto.
+ *
+ * O texto de ajuda mora AO LADO da operação de propósito: é ele que o modelo
+ * lê (`primocode video help`) para saber o que existe, e ajuda escrita
+ * noutro arquivo envelhece diferente do código. Cada linha é curta, com a
+ * unidade de cada número — quadro na linha do tempo, segundo na origem.
+ *
+ * Toda operação que MUDA o projeto passa por `mutar`: foto de antes, edição,
+ * validação, gravação, delta. Se qualquer passo falha, nada é gravado — um
+ * add_clips de dez clipes com um errado não deixa nove pela metade.
+ */
+
+'use strict';
+
+const T = require('./timeline.js');
+const E = require('./edits.js');
+const F = require('./filters.js');
+const { diff } = require('./delta.js');
+const P = require('./projeto.js');
+const TR = require('./transcript.js');
+const A = require('./analise.js');
+
+const r = () => require('./render.js');   // só carrega o ffmpeg quando precisa
+
+const lista = (v) => (v === undefined ? [] : Array.isArray(v) ? v : [v]);
+
+/** Os clipes que a operação pediu: ids, id, ou "all" (todos os visuais). */
+function alvos(tl, args, { tipos = ['video', 'image'] } = {}) {
+    const refs = lista(args.ids !== undefined ? args.ids : args.id);
+    if (!refs.length) throw T.erro('faltou "ids" (ou "all")');
+    if (refs.length === 1 && (refs[0] === 'all' || refs[0] === '*')) {
+        return T.todosOsClipes(tl).filter((x) => tipos.includes(x.clip.type)).map((x) => x.clip.id);
+    }
+    return refs.map((ref) => T.achar(tl, ref).clip.id);
+}
+
+async function mutar(ctx, op, fn) {
+    const antes = T.clone(ctx.tl);
+    const extra = (await fn(ctx.tl)) || {};
+    T.ordenar(ctx.tl);
+    const probs = T.problemas(ctx.tl);
+    if (probs.length) throw T.erro(`edição recusada (nada mudou): ${probs.slice(0, 4).join('; ')}`);
+    P.fotografar(ctx.p, antes, op);
+    P.salvar(ctx.p, ctx.tl);
+    const d = diff(antes, ctx.tl, extra);
+    P.anotar(ctx.p, op, { dur: d.dur, added: (d.added || []).length, removed: (d.removed || []).length });
+    return d;
+}
+
+function precisaProjeto(ctx) {
+    if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."} (cria o projeto) ou new');
+}
+
+// ── as operações ─────────────────────────────────────────────────────────
+
+const OPS = {
+    new: {
+        uso: 'new {name?,width?:1080,height?:1920,fps?:30} — cria projeto em ./video/<id>/ e o torna atual',
+        async run(ctx, a) {
+            const { p, tl } = P.criar({ nome: a.name, width: a.width, height: a.height, fps: a.fps });
+            return { ok: true, project: p.id, dir: p.dir, fps: tl.fps, size: `${tl.width}x${tl.height}` };
+        },
+    },
+    open: {
+        uso: 'open {id} | list {} — troca de projeto / lista os projetos desta pasta',
+        async run(ctx, a) {
+            const x = P.abrir(a.id);
+            if (!x) throw T.erro(`não há projeto "${a.id}"`);
+            P.usar(x.p.id);
+            return { ok: true, project: x.p.id, ...T.vista(x.tl) };
+        },
+    },
+    list: { oculto: true, async run() { return { ok: true, current: P.atual(), projects: P.listar() }; } },
+    import: {
+        uso: 'import {path|paths[],track?,at?,from?,to?,noClip?} — mídia vira asset + clipe no fim da faixa (sem projeto, cria um do tamanho do vídeo)',
+        async run(ctx, a) {
+            const caminhos = lista(a.paths || a.path);
+            if (!caminhos.length) throw T.erro('faltou "path"');
+            if (!ctx.tl) {
+                const probe = await r().medirAsset(T.novo(), caminhos[0]);
+                const vert = probe.width && probe.height;
+                const x = P.criar({ nome: a.name || probe.nome.replace(/\.[^.]+$/, ''),
+                    width: a.width || (vert ? probe.width : 1080), height: a.height || (vert ? probe.height : 1920),
+                    fps: a.fps || (probe.fps ? Math.min(60, Math.round(probe.fps)) : 30) });
+                Object.assign(ctx, x);
+            }
+            const medidos = [];
+            for (const c of caminhos) medidos.push(await r().medirAsset(ctx.tl, c));
+            return mutar(ctx, 'import', (tl) => {
+                for (const m of medidos) {
+                    m.id = T.novoAssetId(tl);
+                    tl.assets[m.id] = m;
+                    if (!a.noClip) E.adicionar(tl, { asset: m.id, track: a.track, at: a.at, from: a.from, to: a.to });
+                }
+                return { project: ctx.p.id };
+            });
+        },
+    },
+    get_timeline: {
+        uso: 'get_timeline {from?,to?} — o projeto compacto (só o que não é padrão). src=[s,s] segundos da origem',
+        async run(ctx, a) { precisaProjeto(ctx); return { ok: true, project: ctx.p.id, ...T.vista(ctx.tl, a) }; },
+    },
+    inspect: {
+        uso: 'inspect {frames:[f..]|at:f} — renderiza os quadros com grade 0–1 + nº do quadro numa folha PNG (abra e OLHE)',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const d = T.duracao(ctx.tl);
+            const frames = a.frames ? lista(a.frames) : a.at !== undefined ? [a.at] : [0, Math.floor(d / 2), d - 1];
+            return r().inspecionar(ctx.p.dir, ctx.tl, { frames, escala: a.scale || 0.5, out: a.out });
+        },
+    },
+    get_transcript: {
+        uso: 'get_transcript {asset?,from?,to?,force?} — palavras [i,texto,f,e] em QUADROS da timeline atual; i é estável entre edições',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const asset = T.acharAsset(ctx.tl, a.asset);
+            const t = await TR.obter(ctx.p.dir, asset, { force: a.force, idioma: a.lang || 'pt' });
+            if (!t.ok) return t;
+            const mapa = TR.mapear(ctx.tl, asset.id, t.palavras)
+                .filter((w) => w.e > (a.from || 0) && w.f < (a.to === undefined ? Infinity : a.to));
+            return { ok: true, asset: asset.id, fonte: t.fonte, total: t.palavras.length, onTimeline: mapa.length, words: mapa.map((w) => [w.i, w.texto, w.f, w.e]) };
+        },
+    },
+    add_clips: {
+        uso: 'add_clips {clips:[{asset,track?,at?,from?,to?|dur?,...props}]} — lote atômico (tudo ou nada)',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            return mutar(ctx, 'add_clips', (tl) => { lista(a.clips).forEach((c) => E.adicionar(tl, c)); });
+        },
+    },
+    insert: {
+        uso: 'insert {asset|type:"text",at,from?,to?|dur?,track?,rippleTracks?} — insere empurrando tudo depois de at (ripple)',
+        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'insert', (tl) => { E.inserir(tl, a); }); },
+    },
+    move: {
+        uso: 'move {id,to?(quadro),track?(índice|"new")} — move sem ripple (sobrepor na mesma faixa é recusado)',
+        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'move', (tl) => { E.mover(tl, a.id, a); }); },
+    },
+    remove: {
+        uso: 'remove {ids,ripple?:false} — apaga clipes; ripple fecha o buraco se nenhuma faixa usa o trecho',
+        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'remove', (tl) => { E.remover(tl, lista(a.ids || a.id), { ripple: a.ripple }); }); },
+    },
+    split: {
+        uso: 'split {id,at(quadro da timeline)} — divide em dois',
+        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'split', (tl) => { E.dividir(tl, a.id, a.at); }); },
+    },
+    ripple_delete_ranges: {
+        uso: 'ripple_delete_ranges {ranges:[[de,ate],..](quadros, ate exclusivo),tracks?} — apaga trechos em todas as faixas e fecha',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            return mutar(ctx, 'ripple_delete_ranges', (tl) => E.apagarTrechos(tl, lista(a.ranges), { tracks: a.tracks }));
+        },
+    },
+    remove_silence: {
+        uso: 'remove_silence {asset?,threshold?:-35(dB),minSilence?:0.5(s),padding?:0.15(s),dryRun?} — silencedetect → ripple',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const asset = T.acharAsset(ctx.tl, a.asset);
+            const sil = await r().silenciosDe(ctx.p.dir, asset, { threshold: a.threshold ?? -35, minSilence: a.minSilence ?? 0.5 });
+            const clipes = T.todosOsClipes(ctx.tl).map((x) => x.clip).filter((c) => c.asset === asset.id);
+            const ranges = A.trechosDeSilencio(ctx.tl, clipes, { [asset.id]: sil }, { padding: a.padding ?? 0.15 });
+            if (a.dryRun) return { ok: true, silences: sil.length, ranges: E.juntar(ranges) };
+            return mutar(ctx, 'remove_silence', (tl) => ({ silences: sil.length, ...E.apagarTrechos(tl, ranges) }));
+        },
+    },
+    remove_words: {
+        uso: 'remove_words {words:[i..],asset?} — apaga as palavras (índices do get_transcript) com ripple',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const asset = T.acharAsset(ctx.tl, a.asset);
+            const t = await TR.obter(ctx.p.dir, asset);
+            if (!t.ok) return t;
+            const { ranges, faltou } = E.trechosDasPalavras(TR.mapear(ctx.tl, asset.id, t.palavras), lista(a.words));
+            if (!ranges.length) throw T.erro('nenhuma dessas palavras está na timeline');
+            return mutar(ctx, 'remove_words', (tl) => ({ ...E.apagarTrechos(tl, ranges), ...(faltou.length ? { notOnTimeline: faltou } : {}) }));
+        },
+    },
+    set_clip_properties: {
+        uso: 'set_clip_properties {ids|"all",props:{volume,opacity,speed,fadeIn,fadeOut(quadros),dur,cx,cy,w,h,rotation,crop{l,t,r,b},fit(cover|contain|stretch),hidden,content,style,animation}}',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            return mutar(ctx, 'set_clip_properties', (tl) => { E.propriedades(tl, alvos(tl, a, { tipos: ['video', 'image', 'audio', 'text'] }), a.props || {}); });
+        },
+    },
+    set_keyframes: {
+        uso: 'set_keyframes {id,prop(zoom|cx|cy|rotation|opacity|volume),keys:[{frame(timeline),value,interp?:ease|linear|hold}]} — keys:[] limpa',
+        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'set_keyframes', (tl) => { E.keyframes(tl, a.id, a.prop, a.keys); }); },
+    },
+    apply_layout: {
+        uso: `apply_layout {layout(${E.LAYOUTS.join('|')}),ids:[principal,..],size?:0.34} — posiciona (transform 0–1)`,
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            return mutar(ctx, 'apply_layout', (tl) => { const av = E.layout(tl, a.layout, lista(a.ids), a); return av.length ? { avisos: av } : {}; });
+        },
+    },
+    add_texts: {
+        uso: 'add_texts {texts:[{content,at,dur(quadros),cx?,cy?,w?,animation?,style?}]} — títulos/letreiros',
+        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'add_texts', (tl) => { E.textos(tl, lista(a.texts)); }); },
+    },
+    add_captions: {
+        uso: 'add_captions {asset?,maxWords?:3,animation?:highlightPop,cy?:0.72,style?} — legenda da transcrição, já nos cortes atuais (refazer substitui)',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const asset = T.acharAsset(ctx.tl, a.asset);
+            const t = await TR.obter(ctx.p.dir, asset);
+            if (!t.ok) return t;
+            return mutar(ctx, 'add_captions', (tl) => ({ captions: E.legendas(tl, TR.mapear(tl, asset.id, t.palavras), a).length }));
+        },
+    },
+    apply_color: {
+        uso: `apply_color {ids|"all",preset?(${Object.keys(F.PRESETS_COR).join('|')}),exposure,contrast,saturation,temperature,tint(-1..1),gamma}`,
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const ef = F.efeitoDeCor(a);
+            return mutar(ctx, 'apply_color', (tl) => {
+                for (const id of alvos(tl, a)) { const { clip } = T.achar(tl, id); clip.effects = clip.effects.filter((e) => e.type !== 'color.adjust').concat(ef); }
+            });
+        },
+    },
+    apply_effect: {
+        uso: `apply_effect {ids|"all",type(${Object.keys(F.EFEITOS).filter((k) => k !== 'color.adjust').join('|')}),params?,remove?:true}`,
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const ef = { type: a.type, params: a.params || {} };
+            if (!a.remove) F.filtrosDoEfeito(ef);
+            return mutar(ctx, 'apply_effect', (tl) => {
+                for (const id of alvos(tl, a)) {
+                    const { clip } = T.achar(tl, id);
+                    clip.effects = clip.effects.filter((e) => e.type !== a.type);
+                    if (!a.remove) clip.effects.push(ef);
+                }
+            });
+        },
+    },
+    detect_beats: {
+        uso: 'detect_beats {asset,sensitivity?:1.4,markers?:false} — batidas em quadros da timeline (+bpm); markers:true grava marcadores',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const asset = T.acharAsset(ctx.tl, a.asset);
+            const taxa = 22050;
+            const b = A.batidas(await r().amostras(asset.path, taxa), taxa, { sensibilidade: a.sensitivity || 1.4 });
+            const clipes = T.todosOsClipes(ctx.tl).map((x) => x.clip).filter((c) => c.asset === asset.id);
+            const quadros = clipes.length
+                ? [...new Set(clipes.flatMap((c) => b.beats.map((s) => T.origemParaQuadro(ctx.tl, c, s)).filter((f) => f !== null)))].sort((x, y) => x - y)
+                : b.beats.map((s) => T.quadros(ctx.tl, s));
+            const res = { bpm: b.bpm, count: quadros.length, beats: quadros.slice(0, 300) };
+            if (!a.markers) return { ok: true, ...res };
+            return mutar(ctx, 'detect_beats', (tl) => {
+                tl.markers = tl.markers.filter((m) => m.label !== 'beat').concat(quadros.map((f) => ({ frame: f, label: 'beat' })));
+                return res;
+            });
+        },
+    },
+    undo: {
+        uso: 'undo {steps?:1} — volta edições (cada edição guarda foto; edite sem pedir licença)',
+        async run(ctx, a) {
+            precisaProjeto(ctx);
+            const antes = ctx.tl;
+            const u = P.desfazer(ctx.p, a.steps || 1);
+            P.salvar(ctx.p, u.tl);
+            ctx.tl = u.tl;
+            return diff(antes, u.tl, { undone: u.desfeitas, left: u.restam });
+        },
+    },
+    export: {
+        uso: 'export {out?,from?,to?(quadros),preview?:false(meia resolução),crf?:20} — renderiza o mp4',
+        async run(ctx, a) { precisaProjeto(ctx); return r().exportar(ctx.p.dir, ctx.tl, a); },
+    },
+};
+
+// Os efeitos que seguem a pessoa (rastro, camadas, objetos 3D, legenda na cabeça) e o pedido em português.
+const FXO = require('./ops-fx.js');
+const PED = require('./pedido.js');
+const AUTO = require('./auto.js');
+Object.assign(OPS, FXO.OPS, PED.OPS, AUTO.OPS);
+
+const ALIAS = { timeline: 'get_timeline', transcript: 'get_transcript', captions: 'add_captions', texts: 'add_texts', render: 'export', pedido: 'do', analyze: 'track' };
+
+// Um exemplo por operação: o modelo copia a forma, e não inventa a chave.
+const EX = {
+    new: '{"name":"aula","width":1920,"height":1080,"fps":30}',
+    open: '{"id":"2026-09-29-aula"}',
+    import: '{"path":"gravacao.mp4"}',
+    get_timeline: '{"from":0,"to":300}',
+    inspect: '{"frames":[0,150,299]}',
+    get_transcript: '{"from":0,"to":600}',
+    add_clips: '{"clips":[{"asset":"a2","track":"new","at":90,"from":2.5,"to":6}]}',
+    insert: '{"asset":"a2","at":120,"from":0,"to":3}',
+    move: '{"id":"3f2a","to":240,"track":"new"}',
+    remove: '{"ids":["3f2a"],"ripple":true}',
+    split: '{"id":"3f2a","at":180}',
+    ripple_delete_ranges: '{"ranges":[[120,150],[400,410]]}',
+    remove_silence: '{"padding":0.12,"minSilence":0.4}',
+    remove_words: '{"words":[12,13,14]}',
+    set_clip_properties: '{"ids":["3f2a"],"props":{"volume":0.3,"fadeIn":15,"opacity":0.9}}',
+    set_keyframes: '{"id":"3f2a","prop":"zoom","keys":[{"frame":60,"value":1},{"frame":64,"value":1.2}]}',
+    apply_layout: '{"layout":"pip_br","ids":["<fala>","<broll>"]}',
+    add_texts: '{"texts":[{"content":"3 DICAS","at":0,"dur":60,"cy":0.2,"animation":"popIn","style":{"bg":"#E11D48"}}]}',
+    add_captions: '{"maxWords":3,"animation":"highlightPop","style":{"upper":true}}',
+    apply_color: '{"ids":"all","preset":"warm","contrast":0.1}',
+    apply_effect: '{"ids":["3f2a"],"type":"stylize.vignette","params":{"strength":0.6}}',
+    detect_beats: '{"asset":"a3","markers":true}',
+    undo: '{"steps":2}',
+    export: '{"out":"final.mp4"}',
+};
+
+const EFEITOS = new Set([...Object.keys(FXO.OPS), ...Object.keys(PED.OPS), ...Object.keys(AUTO.OPS)]);
+
+/* A ajuda principal fica curta (o modelo a lê inteira a cada tarefa): os
+   efeitos entram num resumo de três linhas, e o detalhe em `help efeitos`. */
+function ajuda(secao) {
+    Object.assign(EX, FXO.EX, PED.EX, AUTO.EX);
+    const linha = (nome, o, linhas) => {
+        linhas.push('  ' + o.uso);
+        if (EX[nome]) linhas.push(`      ex: primocode video ${nome} --json '${EX[nome]}'`);
+    };
+    if (secao === 'efeitos' || secao === 'fx') {
+        const linhas = ['EFEITOS QUE SEGUEM A PESSOA — o rastro (MediaPipe) roda 1x por mídia, em paralelo; o 3D renderiza no export (Remotion).',
+            'Momentos: um quadro, "snap" (o estalo do áudio), "junta"/"abre" (as mãos) ou "palavra:<texto>" (quando é dito).',
+            'Receitas em segundos da ORIGEM: cortar silêncio depois não desalinha nada. hand left/right = lado da TELA.'];
+        for (const nome of EFEITOS) linha(nome, OPS[nome], linhas);
+        return linhas.join('\n');
+    }
+    const linhas = [
+        "primocode video <op> [--json '{...}'] [--project <id>]   — editor de vídeo por linha do tempo (ffmpeg)",
+        'UNIDADES: posição/duração na timeline = QUADROS inteiros (fps do projeto); from/to da mídia = SEGUNDOS da origem.',
+        'Faixa 0 = a de cima. cx,cy,w,h em 0–1 do quadro (cx,cy = centro). Clipe por id curto ou prefixo único. Mídia: a1, a2…',
+        'Toda edição devolve um DELTA (added/removed/changed/shifted[{by,ids}]/dur) e é desfeita com undo — não peça licença.',
+        'Saída: 1 linha JSON no stdout (ok:false + error se falhou). Depois de editar, use inspect e OLHE o png.',
+    ];
+    for (const [nome, o] of Object.entries(OPS)) {
+        if (o.oculto || EFEITOS.has(nome)) continue;
+        linha(nome, o, linhas);
+    }
+    linhas.push(
+        'Texto: animation none|fade|popIn|typewriter|wordReveal|highlightPop; style {size(0–1 da altura),color,stroke,',
+        '  strokeWidth,highlight,bg,upper,font(bold|black|regular|caminho .ttf),align}.',
+        'EFEITOS (recorte, fundo no estalo, logo 3D na mão, cérebro, legenda na cabeça) — detalhe: primocode video help efeitos',
+        '  track · separate_layers{show3d} · replace_background{with,at:"snap"} · attach_3d{object,hand} · merge_on_join · cut_silence_at · style_captions{color,position:"above_head"}',
+        `  do {pedido:"<português>"} — ex.: primocode video do --json '{"pedido":"quando eu estalar o dedo me coloca numa praia"}'`,
+        `  auto {} — O VÍDEO É O PEDIDO: lê o que a pessoa fala na gravação e aplica cada efeito no momento em que ela diz. "Edite esse vídeo" sem dizer o quê: import e auto`,
+    );
+    return linhas.join('\n');
+}
+
+module.exports = { OPS, ALIAS, ajuda, mutar, alvos };

package/lib/video/paralelo.js

@@ -0,0 +1,50 @@
+/**
+ * paralelo.js — repartir o trabalho do vídeo entre vários processos.
+ *
+ *   "Um sistema que delega as tarefas para vários trabalhadores, para o
+ *    vídeo sair mais rápido." (30/09/2026)
+ *
+ * Duas regras, e é delas que vem a CORREÇÃO:
+ *
+ *   · as emendas são FIXAS (de `tamanho` em `tamanho` quadros), e não "o
+ *     vídeo dividido pelo número de núcleos". O número de processos só muda
+ *     quantas partes rodam ao mesmo tempo — o resultado é o mesmo numa
+ *     máquina de 4 núcleos e numa de 16;
+ *   · o resultado volta NA ORDEM das tarefas, seja qual for a ordem em que
+ *     terminaram.
+ */
+
+'use strict';
+
+const os = require('os');
+
+/** Quantos trabalhadores: os núcleos menos um (o sistema e o ffmpeg respiram). */
+function quantos(max = Infinity) {
+    const env = Number(process.env.PRIMOCODE_TRABALHADORES);
+    const n = env > 0 ? env : Math.max(1, (os.cpus() || []).length - 1);
+    return Math.max(1, Math.min(max, n));
+}
+
+/** As partes [de, ate) de `total` quadros, de `tamanho` em `tamanho`. A última vai até o fim (ate: null). */
+function partes(total, tamanho = 96) {
+    const out = [];
+    for (let de = 0; de < total; de += tamanho) out.push({ de, ate: de + tamanho >= total ? null : de + tamanho });
+    if (!out.length) out.push({ de: 0, ate: null });
+    return out;
+}
+
+/** Roda `tarefas` (funções que devolvem promessa) com no máximo `n` ao mesmo tempo. Resultado na ordem. */
+async function emParalelo(tarefas, n = quantos()) {
+    const res = new Array(tarefas.length);
+    let prox = 0;
+    const trabalhador = async () => {
+        while (prox < tarefas.length) {
+            const i = prox++;
+            res[i] = await tarefas[i]();
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(n, tarefas.length) }, trabalhador));
+    return res;
+}
+
+module.exports = { quantos, partes, emParalelo };

package/lib/video/pedido.js

@@ -0,0 +1,191 @@
+/**
+ * pedido.js — `primocode video do {"pedido":"..."}`: o pedido em português
+ * vira operações do editor, por REGRA (palavras-chave), sem modelo.
+ *
+ *   "Tira o fundo e separa em camadas. Quando eu estalar o dedo me coloca
+ *    numa praia. Põe o logo do ChatGPT na minha mão, e o do Claude nessa.
+ *    Quando eu juntar as mãos vira um cérebro. Corta o silêncio depois do
+ *    estalo. A legenda eu quero azul, em cima da minha cabeça."
+ *
+ * Por que regra e não o modelo: o modelo que dirige o editor pode ser um
+ * modelo grátis e pequeno. O pedido comum ("legenda azul") tem que dar
+ * certo sempre, igual, em milissegundos — e o que a regra não entende volta
+ * como "não entendi" com os exemplos, para o modelo usar as operações à mão.
+ *
+ * `interpretar` é pura (o teste roda cada frase); `do` executa o plano,
+ * adiantando EM PARALELO o que é lento e independente (rastreio e
+ * transcrição) antes do primeiro passo.
+ */
+
+'use strict';
+
+const C = require('./camadas.js');
+
+const tira = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+
+const LUGARES = ['praia', 'espaco', 'cidade', 'floresta', 'montanha', 'escritorio', 'deserto', 'neve', 'por do sol', 'paris', 'nova york', 'mar'];
+const NOMES_COR = Object.keys(C.CORES).filter((k) => !/[^a-z ]/.test(k)).sort((a, b) => b.length - a.length);
+
+/** A cor PEDIDA: ignora a que só descreve o estado atual ("ela está amarela"). */
+function corPedida(t) {
+    const limpo = t.replace(/\b(esta|ta|e|era|estava|tava|ficou)\s+(\w+)/g, (m, v, w) => (NOMES_COR.includes(w) ? ' ' : m));
+    let melhor = null;
+    for (const nome of NOMES_COR) {
+        const m = new RegExp(`\\b${nome}\\b`).exec(limpo);
+        if (m && (melhor === null || m.index < melhor.i)) melhor = { i: m.index, nome };
+    }
+    return melhor && melhor.nome;
+}
+
+function lugar(t) {
+    for (const l of LUGARES) if (new RegExp(`\\b${l}\\b`).test(t)) return l;
+    const m = t.match(/\bfundo\s+(?:de|com|do|da|num|numa)\s+(?:um|uma\s+)?([a-z][a-z ]{2,30}?)(?=[,.;!?]|\s+e\s|\s+quando|$)/);
+    return m ? m[1].trim() : null;
+}
+
+/** Onde cada objeto é citado, em ordem, com a mão dita logo depois. */
+function objetosCitados(t) {
+    const out = [];
+    const re = /\b(chat ?gpt|gpt|openai|claude|anthropic|chrome|drive)\b|\blogo\s+d[aoe]s?\s+([a-z0-9]+)/g;
+    let m;
+    const todas = [];
+    while ((m = re.exec(t))) todas.push(m);
+    for (let k = 0; k < todas.length; k++) {
+        m = todas[k];
+        const nome = m[1] || m[2];
+        const modelo = C.modeloDe(nome);
+        if (!modelo && m[2] && /^(chat|gpt|claude)/.test(m[2])) continue;
+        if (out.some((o) => o.pos === m.index)) continue;
+        // A mão dita vale até a próxima citação: "ChatGPT na mão, e o do Claude nessa" — o "nessa" é do Claude.
+        const prox = todas.slice(k + 1).find((x) => x.index > m.index + m[0].length);
+        const depois = t.slice(m.index, Math.min(m.index + 70, prox ? prox.index : Infinity));
+        const mao = /\besquerd/.test(depois) ? 'left' : /\bdireit/.test(depois) ? 'right'
+            : /\b(nessa|nesta|outra|dessa|desta|nessa aqui|na outra)\b/.test(depois) ? 'other' : null;
+        if (modelo === 'cerebro') continue;
+        const item = { object: modelo || nome, pos: m.index, mao };
+        // "o logo do ChatGPT": a mesma citação casou duas vezes.
+        if (out.length && out[out.length - 1].object === item.object && m.index - out[out.length - 1].pos < 14) continue;
+        out.push(item);
+    }
+    return out;
+}
+
+/**
+ * pedido → {passos:[{op,args}], avisos}. `ctx`: {temLegenda, objetos:[{modelo,mao}]}.
+ */
+function interpretar(pedido, ctx = {}) {
+    const t = tira(pedido).replace(/\s+/g, ' ');
+    const passos = [];
+    const avisos = [];
+    const add = (op, args = {}) => passos.push({ op, args });
+
+    const camadas = /\bcamadas?\b|\b3d\b|tres dimens/.test(t);
+    const tiraFundo = /\b(tir\w*|remov\w*|apag\w*|recort\w*)\s+(?:o\s+|do\s+|meu\s+)?fundo\b|\brecort\w*\s+(?:eu|me|a pessoa)\b|\bme\s+recort/.test(t);
+    const estalo = /\bestal\w*|\bsnap\b|\bdedo\b/.test(t);
+    const onde = lugar(t);
+    const trocaFundo = !!onde && /\b(coloc\w*|poe|pon\w*|bot\w*|lev\w*|transport\w*|troc\w*|mud\w*|fundo|joga\w*)\b/.test(t);
+
+    if (camadas && /\bsepar\w*|camadas\b/.test(t)) add('separate_layers', { show3d: true });
+    else if (tiraFundo && !trocaFundo) add('separate_layers', {});
+
+    if (trocaFundo) add('replace_background', { with: onde, ...(estalo ? { at: 'snap' } : {}) });
+
+    const objs = objetosCitados(t);
+    let anteriores = (ctx.objetos || []).length;
+    for (const o of objs) {
+        const hand = o.mao || (anteriores > 0 ? 'other' : 'auto');
+        add('attach_3d', { object: o.object, hand });
+        anteriores++;
+    }
+
+    const cerebro = /\bcerebro\b|\bbrain\b/.test(t);
+    const juntar = /\bjunt\w*\s+(?:as\s+|minhas\s+)?maos\b|\bmaos\s+juntas\b|\bfund\w*\s+(?:os|as)\b|\bjunt\w*\s+(?:os|as)\s+(?:dois|duas|logos)\b/.test(t);
+    if (juntar || (cerebro && objs.length + (ctx.objetos || []).length)) add('merge_on_join', { then: cerebro ? 'brain' : 'none' });
+    else if (cerebro) add('attach_3d', { object: 'brain', hand: 'auto' });
+
+    if (/\b(cort\w*|tir\w*|remov\w*|apag\w*)\s+(?:o\s+|os\s+|esse\s+|aquele\s+)?silencios?\b/.test(t)) {
+        if (estalo) add('cut_silence_at', { event: 'snap' });
+        else add('remove_silence', {});
+    }
+
+    if (/\blegenda/.test(t)) {
+        const cor = corPedida(t);
+        let position = null;
+        if (/\b(em cima|acima|sobre|por cima|encima)\s+da\s+(?:minha\s+)?cabeca\b/.test(t)) position = 'above_head';
+        else if (/\b(embaixo|em baixo|rodape|parte de baixo|la embaixo)\b/.test(t)) position = 'bottom';
+        else if (/\b(no topo|la em cima|parte de cima)\b/.test(t)) position = 'top';
+        else if (/\b(no meio|no centro|centralizad)\w*/.test(t)) position = 'center';
+        const estilo = {};
+        if (cor) estilo.color = cor;
+        if (position) estilo.position = position;
+        if (!ctx.temLegenda) add('add_captions', {});
+        if (Object.keys(estilo).length) add('style_captions', estilo);
+        else if (ctx.temLegenda) avisos.push('a legenda já existe: diga a cor ou a posição (ex.: "legenda azul", "em cima da minha cabeça")');
+    }
+
+    return { passos, avisos };
+}
+
+const EXEMPLOS = [
+    'tira o fundo e separa em camadas', 'quando eu estalar o dedo me coloca numa praia', 'põe o logo do ChatGPT na minha mão',
+    'e o do Claude nessa', 'quando eu juntar as mãos vira um cérebro', 'corta o silêncio depois do estalo',
+    'essa legenda eu quero azul', 'quero a legenda em cima da minha cabeça',
+];
+
+const OPS = {
+    do: {
+        uso: 'do {pedido:"<português>",dryRun?} — ex.: "tira o fundo e separa em camadas", "quando eu estalar o dedo me coloca numa praia", "põe o logo do ChatGPT na minha mão", "o do Claude nessa", "quando eu juntar as mãos vira um cérebro", "corta o silêncio depois do estalo", "legenda azul em cima da minha cabeça"',
+        async run(ctx, a) {
+            const T = require('./timeline.js');
+            const pedido = a.pedido || a.request || a.texto;
+            if (!pedido) throw T.erro('faltou "pedido"');
+            const tl = ctx.tl;
+            const info = {
+                temLegenda: !!tl && T.todosOsClipes(tl).some((x) => x.clip.caption),
+                objetos: tl && tl.fx ? Object.values(tl.fx).flatMap((v) => v.objetos || []) : [],
+            };
+            const plano = interpretar(pedido, info);
+            if (!plano.passos.length) {
+                return { ok: false, error: 'não entendi o pedido (nenhuma regra casou)', exemplos: EXEMPLOS,
+                    dica: 'use as operações direto: primocode video help' };
+            }
+            const resumo = plano.passos.map((p) => ({ op: p.op, args: p.args }));
+            if (a.dryRun) return { ok: true, plano: resumo, ...(plano.avisos.length ? { avisos: plano.avisos } : {}) };
+            if (!tl) throw T.erro('nenhum projeto aberto: import {"path":"..."} primeiro');
+            const { OPS: TODAS } = require('./ops.js');
+            // O que é lento e não depende de nada roda JUNTO antes do primeiro passo.
+            const C2 = require('./camadas.js');
+            const asset = C2.base(tl);
+            const precisaRastro = plano.passos.some((p) => p.op !== 'add_captions' && p.op !== 'remove_silence');
+            const precisaFala = plano.passos.some((p) => ['add_captions', 'attach_3d', 'separate_layers'].includes(p.op));
+            const inicio = Date.now();
+            const [rs] = await Promise.all([
+                precisaRastro ? require('./rastrear.js').garantir(ctx.p.dir, asset) : null,
+                precisaFala && asset.hasAudio ? require('./transcript.js').obter(ctx.p.dir, asset).catch(() => null) : null,
+            ]);
+            if (rs && !rs.ok) return rs;
+            const feitos = [];
+            for (const p of plano.passos) {
+                const res = await TODAS[p.op].run(ctx, p.args);
+                feitos.push({ op: p.op, ...compacto(res) });
+                if (!res || res.ok === false) {
+                    return { ok: false, error: `o passo ${p.op} falhou: ${res && res.error}`, feitos, desfazer: feitos.length > 1 ? `undo {"steps":${feitos.length - 1}}` : null };
+                }
+            }
+            return { ok: true, plano: resumo, feitos, tookS: Math.round((Date.now() - inicio) / 100) / 10, ...(plano.avisos.length ? { avisos: plano.avisos } : {}),
+                depois: 'inspect para OLHAR; export renderiza o 3D (Remotion) na primeira vez' };
+        },
+    },
+};
+
+/** O que importa de cada passo, numa linha (o delta inteiro de cada um encheria o contexto). */
+function compacto(res) {
+    if (!res) return { ok: false };
+    const o = { ok: res.ok !== false };
+    for (const k of ['layers', 'show3d', 'background', 'object', 'merge', 'silence', 'removedFrames', 'captions', 'color', 'follow', 'dur', 'error']) if (res[k] !== undefined) o[k] = res[k];
+    return o;
+}
+
+const EX = { do: '{"pedido":"quando eu estalar o dedo me coloca numa praia"}' };
+
+module.exports = { interpretar, corPedida, objetosCitados, lugar, OPS, EX, EXEMPLOS };