primocode 10.5.0 → 10.7.0

package/lib/estudio/personagem.js

@@ -28,6 +28,8 @@
 'use strict';
 
 const { volumesDaTrilha } = require('./ritmo.js');
+const mundo = require('./mundo.js');
+const colecao = require('./colecao.js');
 
 const FPS = 30;
 const r2 = (x) => Math.round(x * 100) / 100;
@@ -63,7 +65,7 @@ const CENARIOS_VOXEL = {
 // O nome antigo do set (podcast, estúdio…) tem um par no voxel.
 const VOXEL_DO_LISO = { podcast: 'telas', estudio: 'oceano', escritorio: 'terra', noite: 'neon' };
 // O mascote é laranja (o do Claude) a menos que o roteiro diga a cor.
-const CORES_MASCOTE = { claude: '#d97757', gpt: '#10a37f', chatgpt: '#10a37f', gemini: '#4f7cff', primo: '#22b8d8', primocode: '#22b8d8' };
+const CORES_MASCOTE = { claude: '#dd5a2b', gpt: '#10a37f', chatgpt: '#10a37f', gemini: '#4f7cff', primo: '#22b8d8', primocode: '#22b8d8' };
 const ROUPAS_VOXEL = ['#c2452f', '#2f4cdd', '#1f8a5b', '#d08a1e', '#7b5cff', '#e8e2d6'];
 // A pele de bloco é um tom mais fundo: sob a luz quente, o tom claro estourava.
 const PELES_VOXEL = ['#d9a07a', '#c08660', '#a8704c', '#8a5a3c', '#6b4229'];
@@ -84,12 +86,44 @@ function rng(semente) {
 }
 
 /** A aparência de quem fala: o que o roteiro disse vale; o resto sai do nome. */
+/* O TIPO de quem fala (11/10, "se eu pedir um cachorro ele vai fazer"):
+   pessoa · robo (o mascote) · animal (uma espécie que o kit/mundo.jsx monta) ·
+   coisa (qualquer objeto com ícone 3D, em blocos: "a pizza conversando com o
+   café"). O que o roteiro disse vale; senão, o NOME decide. */
+const TIPOS = ['pessoa', 'robo', 'animal', 'coisa'];
+function especieDe(txt) {
+    const s = mundo.sem(txt);
+    return Object.keys(mundo.ESPECIES).find((k) => mundo.ESPECIES[k].test(s) || k === s) || null;
+}
+function iconeDe(txt) {
+    const t = String(txt || '').trim().toLowerCase();
+    if (!t) return null;
+    return colecao.melhorIcone3d(t, 80) || (colecao.PT_EN[t] || colecao.PT_EN[mundo.sem(t)] ? colecao.melhorIcone3d(t, 40) : null);
+}
+function tipoDe(nome, pedido = {}) {
+    if (TIPOS.includes(pedido.tipo)) return pedido.tipo;
+    if (pedido.especie) return 'animal';
+    if (pedido.icone || pedido.coisa) return 'coisa';
+    if (especieDe(nome)) return 'animal';
+    if (EH_ROBO.test(nome)) return 'robo';
+    if (iconeDe(nome)) return 'coisa';
+    return 'pessoa';
+}
+
 function aparencia(nome, pedido = {}) {
     const k = (s) => hashDe(nome + ':' + s);
-    const tipo = pedido.tipo === 'robo' || pedido.tipo === 'pessoa' ? pedido.tipo : (EH_ROBO.test(nome) ? 'robo' : 'pessoa');
+    const tipo = tipoDe(nome, pedido);
     const rotulo = String(pedido.rotulo || pedido.nome || nome || '').trim().slice(0, 24);
+    if (tipo === 'animal') {
+        const especie = especieDe(pedido.especie || '') || especieDe(nome) || 'cachorro';
+        return { nome, rotulo, tipo, especie, ...(pedido.cor ? { cor: pedido.cor } : {}), ...(pedido.cor2 ? { cor2: pedido.cor2 } : {}) };
+    }
+    if (tipo === 'coisa') {
+        const termo = String(pedido.icone || pedido.coisa || nome);
+        return { nome, rotulo, tipo, icone: termo, ...(pedido.src ? { src: pedido.src } : {}) };
+    }
     if (tipo === 'robo') {
-        return { nome, rotulo, tipo, cor: pedido.cor || pegar(ROBOS, k('cor')), olhos: pedido.olhos || null };
+        return { nome, rotulo, tipo, cor: pedido.cor || pegar(ROBOS, k('cor')), olhos: pedido.olhos || null, ...(pedido.bigode ? { bigode: true } : {}) };
     }
     return {
         nome, rotulo, tipo,
@@ -99,6 +133,9 @@ function aparencia(nome, pedido = {}) {
         roupa: pedido.roupa || pegar(ROUPAS, k('roupa')),
         oculos: pedido.oculos != null ? !!pedido.oculos : k('oculos') < 0.3,
         barba: !!pedido.barba,   // só quando pedida: sorteada, ficava estranha em quem tem cabelo longo
+        bigode: !!pedido.bigode,
+        // A cabeça facetada (low-poly) é o padrão; 'cubo' é o rosto de pixel da 10.5.
+        ...(pedido.cabeca === 'cubo' ? { cabeca: 'cubo' } : {}),
     };
 }
 
@@ -119,6 +156,22 @@ function destaqueDe(pt, texto) {
     return m ? m[1].trim() : null;
 }
 
+/* O que o corpo faz na fala, além de falar. O roteiro diz (parte.acao); sem
+   ele, o texto sugere: "oi"/"tchau" acena, "olha"/"aqui" aponta, "!" de
+   vitória comemora. kit/voxel.jsx e kit/mundo.jsx desenham cada uma. */
+const ACOES = ['falar', 'acenar', 'apontar', 'pular', 'dancar', 'comemorar', 'pensar', 'andar', 'correr', 'sentar'];
+function acaoDe(pt, texto) {
+    const a = mundo.sem(pt.acao || '').replace(/[^a-z]/g, '');
+    const achada = ACOES.find((x) => a.startsWith(x.slice(0, 5)));
+    if (achada) return achada;
+    const s = mundo.sem(texto);
+    if (/^(oi|ola|e ai|fala,|bom dia|boa tarde|boa noite)\b|\b(tchau|ate mais|ate logo|valeu, ate)\b/.test(s)) return 'acenar';
+    if (/\b(consegui|conseguimos|ganhamos|vencemos|incrivel|isso ai|uhu|eba|viva)\b.*!/.test(s)) return 'comemorar';
+    if (/\b(olha|olhe|veja|repara|ali|aqui o|esse aqui)\b/.test(s)) return 'apontar';
+    if (/\b(sera que|hmm+|deixa eu pensar|pensando)\b/.test(s)) return 'pensar';
+    return 'falar';
+}
+
 const falaDe = (pt) => String(pt.texto || pt.fala || pt.narracao || pt.titulo || '').trim();
 
 /* Sem os tempos da voz, cada fala ganha o tempo de leitura (2,6 palavras/s)
@@ -206,6 +259,36 @@ function paineisDe(falas, roteiro = {}) {
     return out.length ? out : [{ titulo: String(roteiro.titulo || 'Agora').slice(0, 18), linha: '' }];
 }
 
+
+/* BICHO NÃO FALA (11/10, "e o cachorro fala? mds kkk"): fala de bicho com voz
+   de gente fica ridícula. A parte do bicho SAI da narração e ele fica na cena
+   como figurante (abanando o rabo). Ele só fala se o pedido disser que fala:
+   "cachorro falante", "um gato que fala", "o cachorro falando". Muda o
+   roteiro no lugar (o array de partes é o mesmo) e devolve quem calou. */
+function calarBichos(roteiro, pedido = '') {
+    const partes = Array.isArray(roteiro && roteiro.partes) ? roteiro.partes : [];
+    const pedidos = (roteiro && roteiro.personagens) || {};
+    const ped = mundo.sem(pedido);
+    const calados = [];
+    for (let i = partes.length - 1; i >= 0; i--) {
+        const pt = partes[i];
+        const nome = typeof (pt && pt.falante) === 'string' ? pt.falante.trim().toLowerCase() : '';
+        if (!nome) continue;
+        const dado = pedidos[nome] || pedidos[Object.keys(pedidos).find((k) => k.toLowerCase() === nome)] || {};
+        const fala = mundo.sem(partes.filter((x) => String(x.falante || '').trim().toLowerCase() === nome).map(falaDe).join(' '));
+        const latido = /\bau[ -]?au\b|\bau!|\bmiau|\bmu+u\b|\boinc\b|\bquack\b|\bcocoric/.test(fala);
+        const tipo = dado.tipo || (dado.especie ? 'animal' : (especieDe(nome) || latido ? 'animal' : null));
+        if (tipo !== 'animal' || dado.fala === true) continue;
+        const esp = especieDe(dado.especie || '') || especieDe(nome) || (/\bmiau/.test(fala) ? 'gato' : 'cachorro');
+        const falante = new RegExp(`\\b(${Object.keys(mundo.ESPECIES).join('|')}|bicho|animal|${nome})\\w*\\s+(falante|que fala|falando|fala)\\b`).test(ped);
+        if (falante) continue;
+        partes.splice(i, 1);
+        if (!calados.some((c) => c.nome === nome)) calados.push({ nome, especie: esp });
+    }
+    if (calados.length) roteiro.figurantesExtra = [...(roteiro.figurantesExtra || []), ...calados.map((c) => ({ nome: c.nome, tipo: 'animal', especie: c.especie }))];
+    return calados;
+}
+
 /** A partitura inteira: o que o kit/personagem.jsx desenha, quadro a quadro. */
 function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = [] }) {
     const partes = (roteiro.partes || []).filter((p) => p && typeof p === 'object' && falaDe(p));
@@ -220,9 +303,20 @@ function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = []
         if (!nomes.includes(f)) nomes.push(f);
     }
     const pedidos = roteiro.personagens && typeof roteiro.personagens === 'object' ? roteiro.personagens : {};
-    const pedidoDe = (n) => pedidos[n] || pedidos[Object.keys(pedidos).find((k) => k.toLowerCase() === n)] || {};
-    // No set cabem dois; o terceiro em diante divide o lugar (raro num diálogo).
-    const elenco = nomes.slice(0, 2).map((n, i) => ({ ...aparencia(n, pedidoDe(n)), lado: nomes.length > 1 ? (i === 0 ? -1 : 1) : 0 }));
+    /* Quem LATE é cachorro: um falante sem tipo cuja fala tem a voz de um
+       bicho ("Au au!", "Miau") vira aquele bicho — o modelo pequeno escreve o
+       diálogo e esquece de dizer que o Rex é um cachorro. */
+    const VOZ_DE_BICHO = [[/\bau[ -]?au\b|\bau!|\bauau\b|\bwoof\b/, 'cachorro'], [/\bmiau+\b/, 'gato'], [/\bmu+u\b/, 'vaca'], [/\boinc\b/, 'porco'],
+        [/\bquack\b|\bqua[ -]?qua\b/, 'pato'], [/\bcocoric[oó]\b/, 'galinha'], [/\bpiu[ -]?piu\b/, 'passaro'], [/\bme+h+\b|\bbe+h+\b/, 'ovelha'], [/\brua+r+\b|\broar\b/, 'leao']];
+    const pedidoDe = (n) => {
+        const dado = pedidos[n] || pedidos[Object.keys(pedidos).find((k) => k.toLowerCase() === n)] || {};
+        if (dado.tipo || dado.especie) return dado;
+        const fala = mundo.sem(partes.filter((pt) => String(pt.falante || '').trim().toLowerCase() === n).map(falaDe).join(' '));
+        const bicho = VOZ_DE_BICHO.find(([re]) => re.test(fala));
+        return bicho ? { ...dado, tipo: 'animal', especie: bicho[1] } : dado;
+    };
+    // Até QUATRO falam no set ("três amigos no parque"); do quinto em diante dividem o lugar.
+    const elenco = nomes.slice(0, 4).map((n, i) => ({ ...aparencia(n, pedidoDe(n)), lado: nomes.length > 1 ? (i < nomes.length / 2 ? -1 : 1) : 0, ordem: i }));
     const quemDe = (pt) => {
         const f = typeof pt.falante === 'string' && pt.falante.trim() ? pt.falante.trim().toLowerCase() : 'apresentador';
         return nomes.indexOf(f) % Math.max(1, elenco.length);
@@ -235,7 +329,7 @@ function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = []
             .map((w) => ({ t: String(w.texto || w.word || ''), de: r2(w.de), ate: r2(w.ate) }));
         return {
             quem: quemDe(pt), de: r2(t.de != null ? t.de : (palavras[0] || {}).de || 0), ate: r2(t.ate != null ? t.ate : (palavras[palavras.length - 1] || {}).ate || 0),
-            texto, palavras, emocao: emocaoDe(pt, texto), destaque: destaqueDe(pt, texto),
+            texto, palavras, emocao: emocaoDe(pt, texto), destaque: destaqueDe(pt, texto), acao: acaoDe(pt, texto),
         };
     });
     const duracao = r2((falas.length ? falas[falas.length - 1].ate : 3) + 1.2);
@@ -258,14 +352,72 @@ function partituraDe({ roteiro = {}, largura = 1920, altura = 1080, tempos = []
         cenarioFinal = { nome: nomeV, ...CENARIOS_VOXEL[nomeV] };
         if (roteiro.acento && /^#[0-9a-f]{6}$/i.test(roteiro.acento)) cenarioFinal.acento = roteiro.acento;
         for (const e of elenco) {
-            if (e.tipo === 'robo' && !(pedidoDe(e.nome) || {}).cor) e.cor = CORES_MASCOTE[e.nome] || '#d97757';
+            if (e.tipo === 'robo' && !(pedidoDe(e.nome) || {}).cor) e.cor = CORES_MASCOTE[e.nome] || '#dd5a2b';
             if (e.tipo === 'pessoa' && !(pedidoDe(e.nome) || {}).roupa) e.roupa = pegar(ROUPAS_VOXEL, hashDe(e.nome + ':roupa'));
             if (e.tipo === 'pessoa' && !(pedidoDe(e.nome) || {}).pele) e.pele = pegar(PELES_VOXEL, hashDe(e.nome + ':pele'));
             if (e.tipo === 'pessoa' && !(pedidoDe(e.nome) || {}).corCabelo) e.corCabelo = pegar(CABELOS_VOXEL, hashDe(e.nome + ':corCabelo'));
         }
     }
+    /* O MUNDO (mundo.js): o lugar e as coisas. roteiro.cena (texto livre ou
+       objeto) é o do vídeo; parte.cenario muda o lugar a partir daquela fala.
+       O pedido da pessoa e as falas completam o que a cena não disse. */
+    const pedidoTexto = String(roteiro.pedido || roteiro.descricao || '');
+    const textoTodo = [pedidoTexto, roteiro.titulo, ...falas.map((f) => f.texto)].filter(Boolean).join(' ');
+    const cenaBase = roteiro.cena || roteiro.cenario || '';
+    const mundos = [];
+    const indiceDe = (pedido) => {
+        const chave = JSON.stringify(pedido || '');
+        const ja = mundos.findIndex((m) => m.chave === chave);
+        if (ja >= 0) return ja;
+        mundos.push({ chave, ...mundo.mundoDe(pedido, { texto: textoTodo, pedidoTexto, semente: semente + mundos.length * 7, nElenco: elenco.length }) });
+        return mundos.length - 1;
+    };
+    indiceDe(cenaBase);
+    let atual = 0;
+    partes.forEach((pt, i) => {
+        const pedidoParte = pt.cena || pt.cenario;
+        if (pedidoParte) atual = indiceDe(pedidoParte);
+        if (falas[i]) falas[i].mundo = atual;
+    });
+    for (const m of mundos) delete m.chave;
+    // O set da referência (telas) segue com as cores dele; os outros lugares trazem as suas.
+    if (mundos[0].lugar !== 'telas') cenarioFinal = { ...cenarioFinal, nome: mundos[0].nome, parede: mundos[0].parede || mundos[0].ceu?.[1] || cenarioFinal.parede, acento: mundos[0].acento };
+
+    /* OS FIGURANTES: quem o pedido põe na cena e não fala ("um humano com o
+       cachorro", "dois humanos" com um narrador só). roteiro.figurantes manda;
+       senão, os bichos e as pessoas do pedido que sobraram do elenco. */
+    const figurantes = [];
+    if (Array.isArray(roteiro.figurantes)) {
+        for (const f of roteiro.figurantes.slice(0, 4)) {
+            const pedidoF = typeof f === 'string' ? { tipo: tipoDe(f, {}), especie: especieDe(f) || undefined, icone: f } : f || {};
+            const nomeF = typeof f === 'string' ? f : String(f.nome || f.especie || f.icone || 'figurante');
+            figurantes.push({ ...aparencia(nomeF, pedidoF) });
+        }
+    } else if (pedidoTexto) {
+        const lido = mundo.lerElenco(pedidoTexto);
+        const temEspecie = (esp) => elenco.some((e) => e.tipo === 'animal' && e.especie === esp);
+        for (const b of lido.bichos) {
+            for (let k = 0; k < b.quantos - (temEspecie(b.especie) ? 1 : 0) && figurantes.length < 3; k++) {
+                figurantes.push(aparencia(`${b.especie} ${k + 1}`, { tipo: 'animal', especie: b.especie }));
+            }
+        }
+        const pessoas = elenco.filter((e) => e.tipo === 'pessoa').length;
+        for (let k = pessoas; k < lido.pessoas && figurantes.length < 4; k++) figurantes.push(aparencia(`pessoa ${k + 1}`, { tipo: 'pessoa' }));
+    }
+    // Os bichos que calaram (calarBichos) entram como figurantes, antes de tudo.
+    for (const f of (Array.isArray(roteiro.figurantesExtra) ? roteiro.figurantesExtra : []).slice(0, 3)) {
+        if (!figurantes.some((x) => x.nome === f.nome)) figurantes.unshift(aparencia(f.nome, { tipo: 'animal', especie: f.especie }));
+    }
+    // O mesmo bicho que o pedido já pôs como figurante não aparece duas vezes.
+    for (let k = figurantes.length - 1; k > 0; k--) if (figurantes.slice(0, k).some((x) => x.tipo === 'animal' && x.especie === figurantes[k].especie && x !== figurantes[k] && /\d$/.test(figurantes[k].nome))) figurantes.splice(k, 1);
+    if (visual === 'voxel') {
+        for (const e of figurantes) {
+            if (e.tipo === 'pessoa') { e.roupa = pegar(ROUPAS_VOXEL, hashDe(e.nome + ':roupa')); e.pele = pegar(PELES_VOXEL, hashDe(e.nome + ':pele')); e.corCabelo = pegar(CABELOS_VOXEL, hashDe(e.nome + ':corCabelo')); }
+        }
+    }
+
     return {
-        versao: 1, fps: FPS, largura, altura, duracao, semente, cenario: cenarioFinal, elenco, falas, planos, visual,
+        versao: 2, fps: FPS, largura, altura, duracao, semente, cenario: cenarioFinal, elenco, falas, planos, visual, mundos, figurantes,
         paineis: paineisDe(falas, roteiro),
         legenda: roteiro.legenda !== false,
         titulo: typeof roteiro.titulo === 'string' ? roteiro.titulo.slice(0, 60) : '',
@@ -296,8 +448,9 @@ function montarPersonagem({ roteiro, largura = 1920, altura = 1080, tempos = [],
     };
     return {
         ok: true, plano, partitura,
-        resumo: { visual: partitura.visual, cenas: 1, segundos: DUR, fps: FPS, cenario: partitura.cenario.nome, elenco: partitura.elenco.map((e) => `${e.rotulo} (${e.tipo})`), planos: partitura.planos.length, falas: partitura.falas.length },
+        resumo: { visual: partitura.visual, cenas: 1, segundos: DUR, fps: FPS, cenario: partitura.cenario.nome, elenco: partitura.elenco.map((e) => `${e.rotulo} (${e.tipo === 'animal' ? e.especie : e.tipo})`),
+            figurantes: partitura.figurantes.map((e) => (e.tipo === 'animal' ? e.especie : e.tipo)), lugares: partitura.mundos.map((m) => m.nome), planos: partitura.planos.length, falas: partitura.falas.length },
     };
 }
 
-module.exports = { montarPersonagem, partituraDe, planosDe, paineisDe, aparencia, destaqueDe, emocaoDe, CENARIOS, CENARIOS_VOXEL, EH_ROBO, FPS };
+module.exports = { calarBichos, montarPersonagem, partituraDe, planosDe, paineisDe, aparencia, tipoDe, acaoDe, destaqueDe, emocaoDe, CENARIOS, CENARIOS_VOXEL, EH_ROBO, FPS };

package/lib/estudio/plano.js

@@ -49,6 +49,7 @@ const fs = require('fs');
 const path = require('path');
 const morfar = require('./morfar.js');
 const kit = require('./kit.js');
+const movimentos = require('./movimentos.js');
 
 // "kit": uma peça pronta do kit de motion (kit.js), pelo nome — ver kit/*.jsx.
 const TIPOS = new Set(['texto', 'forma', 'imagem', 'video', 'icone', 'legenda', 'componente', 'grupo', 'kit']);
@@ -283,6 +284,11 @@ function conferir(plano, { pasta = null } = {}) {
     if (!plano || typeof plano !== 'object') {
         return { ok: false, problemas: [erro('plano', 'o plano é um objeto JSON')], duracao: 0 };
     }
+    /* `movimento: "quicar-de-baixo"` vira quadros-chave (movimentos.js) antes
+       de tudo: o que segue confere o `anima` como se a IA o tivesse escrito. */
+    for (const d of movimentos.expandir(plano)) {
+        problemas.push(erro(d.onde, `o movimento "${d.nome}" não existe — procure com estudio_midia acao:"movimentos" termo:"…"`));
+    }
 
     const f = plano.formato || {};
     const largura = Number(f.largura) || 1920;

package/lib/estudio/producao.js

@@ -22,11 +22,22 @@
  * provedor nenhum.
  *
  * Puro de propósito: a rede e o disco moram nos provedores, então o teste roda
- * sem chave e sem internet.
+ * sem chave e sem internet. A exceção é o cacheDe(pasta), que guarda o que já
+ * foi produzido num projeto.
+ *
+ * ── UMA NECESSIDADE, UMA CORRENTE ────────────────────────────────────────
+ *   produzirUma(pedido, provedores, { escolha, cache })  a mesma corrente para
+ *       a voz, a trilha e os efeitos do index.js. `escolha` (do roteiro:
+ *       `provedores: { voz: 'kokoro' }`) passa um provedor para a frente.
+ *       O cache é por necessidade + provedor: trocar a voz só refaz a voz.
  */
 
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
 // Quantas fotos cada tipo de parte do cinema costuma consumir.
 const FOTOS = { montagem: 3, climax: 4, numeros: 2, escada: 2, dia: 1 };
 
@@ -63,28 +74,107 @@ function necessidades(roteiro, { falaDe = textoPadrao } = {}) {
     return pedidos;
 }
 
+/** O provedor escolhido no roteiro vai para a frente; o resto segue na ordem. */
+function ordenar(provedores, escolha) {
+    const lista = (provedores || []).filter(Boolean);
+    const i = escolha ? lista.findIndex((pv) => pv.nome === String(escolha).toLowerCase()) : -1;
+    return i > 0 ? [lista[i], ...lista.slice(0, i), ...lista.slice(i + 1)] : lista;
+}
+
+/** A chave do cache: o que a cena pede (pedido.chave, ou o pedido todo) + quem gera. */
+function chaveDe(pedido, nome) {
+    const { destino, ...resto } = pedido || {};
+    const quer = resto.chave !== undefined ? [resto.tipo, resto.chave] : resto;
+    return crypto.createHash('sha1').update(JSON.stringify([quer, nome])).digest('hex').slice(0, 16);
+}
+
+/**
+ * Uma necessidade pela corrente: o primeiro provedor que entrega ganha. Erro,
+ * null ou { ok: false } cai no próximo; indisponível nem é chamado. Antes de
+ * gerar, cada provedor olha o cache dele (a mesma necessidade, o mesmo provedor).
+ */
+async function produzirUma(pedido, provedores, { escolha, cache, log = () => {} } = {}) {
+    const tentou = [];
+    let ultimo = null;
+    for (const pv of ordenar(provedores, escolha)) {
+        if (pv.disponivel && !pv.disponivel()) continue;
+        const chave = chaveDe(pedido, pv.nome);
+        const guardado = cache && cache.ler(chave, pedido);
+        if (guardado) return { ...pedido, ...guardado, ok: true, quem: pv.nome, doCache: true, tentou };
+        let r;
+        try {
+            r = await pv.gerar(pedido);
+            if (r && r.ok !== false) {
+                if (cache && !r.naoGuardar) cache.gravar(chave, r);
+                return { ...pedido, ...r, ok: true, quem: pv.nome, tentou };
+            }
+            tentou.push({ nome: pv.nome, motivo: (r && r.error) || 'não devolveu nada' });
+        } catch (e) {
+            tentou.push({ nome: pv.nome, motivo: (e && e.message) || String(e) });
+        }
+        if (r) ultimo = r;
+        log(`${pedido.tipo}: ${pv.nome} falhou, próximo`);
+    }
+    return { ...pedido, ...(ultimo || {}), ok: false, error: (ultimo && ultimo.error) || `ninguém produziu ${pedido.tipo}`, tentou };
+}
+
 /** Cada pedido pela corrente dos provedores do tipo dele, na ordem da lista. */
-async function produzir(pedidos, provedores, { log = () => {} } = {}) {
+async function produzir(pedidos, provedores, { log = () => {}, escolhas = {}, cache } = {}) {
     const itens = [];
     for (const pedido of pedidos || []) {
-        const tentou = [];
-        let feito = null;
-        for (const pv of (provedores || []).filter((x) => x && x.tipo === pedido.tipo)) {
-            if (pv.disponivel && !pv.disponivel()) continue;
-            try {
-                const r = await pv.gerar(pedido);
-                if (r) { feito = { ...pedido, ...r, ok: true, quem: pv.nome, tentou }; break; }
-                tentou.push({ nome: pv.nome, motivo: 'não devolveu nada' });
-            } catch (e) {
-                tentou.push({ nome: pv.nome, motivo: (e && e.message) || String(e) });
-            }
-            log(`${pedido.tipo}: ${pv.nome} falhou, próximo`);
-        }
-        itens.push(feito || { ...pedido, ok: false, tentou });
+        const daqui = (provedores || []).filter((x) => x && x.tipo === pedido.tipo);
+        itens.push(await produzirUma(pedido, daqui, { escolha: escolhas[pedido.tipo], cache, log }));
     }
     return { itens, faltou: itens.filter((i) => !i.ok) };
 }
 
+/** Os créditos (licença aberta pede atribuição) de tudo o que foi produzido. */
+function creditos(itens) {
+    return [...new Set((itens || []).filter((i) => i && i.ok).map((i) => i.credito).filter(Boolean))];
+}
+
+/** A linha do caderno: quem produziu cada coisa, e se veio do cache. */
+function linhaCaderno(item) {
+    if (!item.ok) return `${item.tipo}: ninguém produziu (${(item.tentou || []).map((t) => t.nome).join(', ') || 'sem provedor'})`;
+    const antes = (item.tentou || []).length ? `; antes falhou: ${item.tentou.map((t) => t.nome).join(', ')}` : '';
+    return `${item.tipo}: ${item.quem} (${item.doCache ? 'do cache' : 'gerou'}${antes})${item.credito ? ' — ' + item.credito : ''}`;
+}
+
+/**
+ * O cache de um projeto: midia/producao/cache.json. O arquivo de `r.arquivo`
+ * (a voz, que depois é acelerada no lugar) é copiado para lá e volta para o
+ * `pedido.destino` no acerto. Caminho "midia/..." que sumiu do disco é erro.
+ */
+function cacheDe(pasta) {
+    const dir = path.join(pasta, 'midia', 'producao');
+    const arq = path.join(dir, 'cache.json');
+    const ler = () => { try { return JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { return {}; } };
+    const caminhos = (v) => (typeof v === 'string' ? (/^midia\//.test(v) ? [v] : [])
+        : v && typeof v === 'object' ? Object.values(v).flatMap(caminhos) : []);
+    return {
+        ler(chave, pedido = {}) {
+            const e = ler()[chave];
+            if (!e) return null;
+            const { arquivoCache, ...r } = e;
+            if (caminhos(r).some((c) => !fs.existsSync(path.join(pasta, c)))) return null;
+            if (arquivoCache) {
+                if (!pedido.destino || !fs.existsSync(path.join(dir, arquivoCache))) return null;
+                fs.copyFileSync(path.join(dir, arquivoCache), pedido.destino);
+            }
+            return r;
+        },
+        gravar(chave, r) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+                const { arquivo, ...resto } = r;
+                const e = { ...resto };
+                if (arquivo && fs.existsSync(arquivo)) { e.arquivoCache = chave + path.extname(arquivo); fs.copyFileSync(arquivo, path.join(dir, e.arquivoCache)); }
+                fs.writeFileSync(arq, JSON.stringify({ ...ler(), [chave]: e }));
+            } catch { /* sem cache */ }
+        },
+    };
+}
+
 /** O resultado no formato que o montarCinema já recebe. */
 function paraCinema({ itens = [] } = {}) {
     const ok = itens.filter((i) => i.ok);
@@ -103,4 +193,4 @@ function paraCinema({ itens = [] } = {}) {
     };
 }
 
-module.exports = { necessidades, produzir, paraCinema, FOTOS };
+module.exports = { necessidades, produzir, produzirUma, ordenar, chaveDe, creditos, linhaCaderno, cacheDe, paraCinema, FOTOS };

package/lib/estudio/projeto.js

@@ -39,10 +39,13 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 
+const { nomeCurto, semColisao } = require('../nome-curto.js');
+
 const CASA = path.join(os.homedir(), '.primocode', 'studio');
 const PROJETOS = path.join(CASA, 'projetos');
 
-/** Nome de pasta a partir do que a pessoa pediu. */
+/* Nome de ARQUIVO (o mp4, o pdf da saída). A pasta do projeto não usa mais
+   isto: ver `criar` e lib/nome-curto.js. */
 function apelidar(bruto) {
     return String(bruto || '')
         .normalize('NFD').replace(/[̀-ͯ]/g, '')
@@ -59,23 +62,64 @@ function garantirCasa() {
     return PROJETOS;
 }
 
-/**
- * Abre um projeto novo.
+/* ── ONDE MORA CADA PROJETO ──────────────────────────────────────────────
+ * Antes: `projetos/2026-10-11-claude-e-humano-conversam-sobre-o-segund`. A
+ * data na frente servia para a lista sair em ordem, e o resto era a frase
+ * cortada no meio. O dono: "essa estrutura de pastas está horrível".
+ *
+ * Agora: `projetos/2026-10/claude-segundo-cerebro`. O MÊS vira pasta (a
+ * ordem cronológica continua de graça, e um mês cabe numa tela), e o nome é
+ * curto e legível (lib/nome-curto.js). O dia exato fica no projeto.json.
  *
- * O id leva a DATA na frente. Não é enfeite: a pasta é listada em ordem
- * alfabética por quase tudo que lê disco, e com a data na frente essa ordem
- * já é a cronológica — que é como se procura um vídeo ("o de semana
- * passada"), não por nome.
+ * O id continua sendo SÓ o nome da pasta — sem o mês. É ele que o modelo
+ * escreve, que vai na memória e que a pessoa cita; pôr barra nele faria o
+ * `pastaDe` recusar (e com razão). Por isso o nome é único entre TODOS os
+ * meses, e quem acha a pasta pelo id é o `pastaDe`, que olha os meses.
+ *
+ * Os projetos antigos (`projetos/2026-09-25-...`) ficam onde estão: nada é
+ * renomeado, e o id antigo continua abrindo o mesmo projeto. */
+const MES = /^\d{4}-\d{2}$/;
+
+function mesDe(data = new Date()) {
+    return `${data.getFullYear()}-${String(data.getMonth() + 1).padStart(2, '0')}`;
+}
+
+/** As pastas de mês que existem, da mais nova para a mais velha. */
+function meses() {
+    try {
+        return fs.readdirSync(PROJETOS, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && MES.test(d.name)).map((d) => d.name).sort().reverse();
+    } catch { return []; }
+}
+
+/** Todos os ids que existem, antigos (soltos) e novos (dentro do mês). */
+function idsTomados() {
+    const ids = [];
+    try {
+        for (const d of fs.readdirSync(PROJETOS, { withFileTypes: true })) {
+            if (d.isDirectory() && !MES.test(d.name)) ids.push(d.name);
+        }
+    } catch { /* casa vazia */ }
+    for (const m of meses()) {
+        try {
+            for (const d of fs.readdirSync(path.join(PROJETOS, m), { withFileTypes: true })) {
+                if (d.isDirectory()) ids.push(d.name);
+            }
+        } catch { /* mês sumiu no meio */ }
+    }
+    return ids;
+}
+
+/**
+ * Abre um projeto novo, em `projetos/<AAAA-MM>/<nome-curto>`.
  */
 function criar({ titulo, pedido, formato = 'video' }) {
     garantirCasa();
-    const dia = new Date().toISOString().slice(0, 10);
-    const base = `${dia}-${apelidar(titulo || pedido)}`;
-    let id = base;
-    let n = 2;
-    while (fs.existsSync(path.join(PROJETOS, id))) { id = `${base}-${n}`; n++; }
+    const texto = titulo || pedido;
+    const base = nomeCurto(texto) || 'projeto';
+    const id = semColisao(base, idsTomados(), `${titulo || ''} ${pedido || ''}`);
 
-    const pasta = path.join(PROJETOS, id);
+    const pasta = path.join(PROJETOS, mesDe(), id);
     for (const sub of ['midia', 'saida', 'entrada']) {
         fs.mkdirSync(path.join(pasta, sub), { recursive: true });
     }
@@ -125,7 +169,18 @@ function pastaDe(id) {
     if (typeof id !== 'string' || !id.trim()) return null;
     const limpo = id.trim();
     if (limpo.includes('/') || limpo.includes('\\') || limpo.includes('..')) return null;
-    return path.join(PROJETOS, limpo);
+    // Um mês não é projeto: "2026-10" como id abriria a pasta do mês inteiro.
+    if (MES.test(limpo)) return null;
+    // O antigo, solto na casa (`2026-09-25-...`), continua valendo.
+    const solto = path.join(PROJETOS, limpo);
+    if (fs.existsSync(solto)) return solto;
+    for (const m of meses()) {
+        const dentro = path.join(PROJETOS, m, limpo);
+        if (fs.existsSync(dentro)) return dentro;
+    }
+    // Não existe ainda: o lugar de antes. Quem precisa que exista (`ler`)
+    // confere o projeto.json; este caminho só serve para dizer onde seria.
+    return solto;
 }
 
 /** O meta de um projeto, ou null. */
@@ -147,14 +202,13 @@ function salvar(id, mudancas) {
 }
 
 /** Todos, do mais novo para o mais velho. */
+/* A ordem vinha do nome (a data na frente). Sem data no nome, ela vem do
+   `criado` do projeto.json — que todo projeto, velho ou novo, tem. */
 function listar({ limite = 50 } = {}) {
     garantirCasa();
-    let nomes = [];
-    try {
-        nomes = fs.readdirSync(PROJETOS, { withFileTypes: true })
-            .filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
-    } catch { return []; }
-    return nomes.slice(0, limite).map(ler).filter(Boolean);
+    const todos = idsTomados().map(ler).filter(Boolean);
+    todos.sort((a, b) => String(b.criado || '').localeCompare(String(a.criado || '')) || (a.id < b.id ? 1 : -1));
+    return todos.slice(0, limite);
 }
 
 // ── o caderno ────────────────────────────────────────────────────────────
@@ -216,7 +270,8 @@ function procurar(texto, { limite = 5 } = {}) {
         return { projeto: p, pontos };
     }).filter((x) => x.pontos > 0);
 
-    pontuados.sort((a, b) => b.pontos - a.pontos || (a.projeto.id < b.projeto.id ? 1 : -1));
+    pontuados.sort((a, b) => b.pontos - a.pontos
+        || String(b.projeto.criado || '').localeCompare(String(a.projeto.criado || '')));
     return pontuados.slice(0, limite).map((x) => x.projeto);
 }
 
@@ -278,7 +333,7 @@ function caminhoDeMidia(id, nome) {
 
 module.exports = {
     CASA, PROJETOS,
-    criar, ler, salvar, listar, procurar, pastaDe, apelidar,
+    criar, ler, salvar, listar, procurar, pastaDe, apelidar, mesDe,
     anotar, caderno,
     lerPlano, salvarPlano, versoes, voltarPara,
     caminhoDeMidia, escreverJSON, lerJSON,