morfeo 0.3.4 → 0.5.0

package/lib/estilo-propio.mjs

@@ -0,0 +1,70 @@
+// Estilo propio del canal (estilo.json en la carpeta del proyecto, lo escribe `morfeo estilo`): nombre, siglas,
+// colores, letra, voz, ritmo y frase de cierre. Se aplica al cargar el proyecto, encima de morfeo.config.mjs:
+// todos los videos salen así salvo que uno diga otra cosa (su `estilo`, `voice` o `speed`).
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const ARCHIVO_ESTILO = 'estilo.json';
+
+/** Letras para títulos (OFL/Apache, del repositorio de Google Fonts). Las dos primeras ya vienen en el paquete. */
+export const LETRAS = {
+	Anton: null,
+	Montserrat: null,
+	'Archivo Black': 'ofl/archivoblack/ArchivoBlack-Regular.ttf',
+	'Bebas Neue': 'ofl/bebasneue/BebasNeue-Regular.ttf',
+	'Luckiest Guy': 'apache/luckiestguy/LuckiestGuy-Regular.ttf',
+	Bangers: 'ofl/bangers/Bangers-Regular.ttf',
+	'Lilita One': 'ofl/lilitaone/LilitaOne-Regular.ttf',
+	'Russo One': 'ofl/russoone/RussoOne-Regular.ttf',
+	'Titan One': 'ofl/titanone/TitanOne-Regular.ttf',
+	'Black Ops One': 'ofl/blackopsone/BlackOpsOne-Regular.ttf',
+	'Rubik Mono One': 'ofl/rubikmonoone/RubikMonoOne-Regular.ttf',
+	'Passion One': 'ofl/passionone/PassionOne-Black.ttf',
+};
+
+/** Ritmo → velocidad de la voz y duración de entradas/transiciones. */
+export const RITMOS = {
+	pausado: {velocidad: 1.05, movimiento: {entrada: 0.6, salida: 0.45, transicion: 0.45, curva: 'suave'}},
+	natural: {velocidad: 1.2, movimiento: {entrada: 0.45, salida: 0.35, transicion: 0.35, curva: 'suave'}},
+	agil: {velocidad: 1.32, movimiento: {entrada: 0.3, salida: 0.25, transicion: 0.25, curva: 'seca'}},
+};
+
+export function leerEstiloPropio(proyecto) {
+	const f = path.join(proyecto, ARCHIVO_ESTILO);
+	if (!fs.existsSync(f)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(f, 'utf8'));
+	} catch (e) {
+		throw new Error(`${ARCHIVO_ESTILO} no es un JSON válido: ${e.message}`);
+	}
+}
+
+/**
+ * Mezcla el estilo propio en la configuración (devuelve una copia). El estilo queda como `mi-estilo`, heredando de
+ * `base`, y es el estilo por defecto del proyecto.
+ */
+export function aplicarEstiloPropio(cfg, e, proyecto) {
+	if (!e) return cfg;
+	const out = {...cfg, marca: {...(cfg.marca ?? {})}, voces: {...(cfg.voces ?? {})}, estilos: {...(cfg.estilos ?? {})}, fuentes: {...(cfg.fuentes ?? {})}};
+	if (e.nombre) out.marca.nombre = e.nombre;
+	if (e.siglas) out.marca.siglas = e.siglas;
+	if (e.colores?.acento) out.marca.color = e.colores.acento;
+	if (e.cierre) out.marca.cta = e.cierre;
+	if (e.letra) out.marca.letra = e.letra;
+	if (e.redes) out.marca.redes = e.redes;
+	const ritmo = RITMOS[e.ritmo] ?? RITMOS.natural;
+	const tema = {base: e.base ?? cfg.estilo ?? 'documental', movimiento: ritmo.movimiento};
+	if (e.colores?.acento) tema.colores = {acento: e.colores.acento, ...(e.colores.acento2 ? {acento2: e.colores.acento2} : {})};
+	if (e.colores?.subtitulo) tema.subtitulos = {resalte: e.colores.subtitulo};
+	if (e.letra && e.letra !== 'Montserrat') {
+		tema.fuentes = {titulo: e.letra};
+		// las letras descargadas viven en fuentes/ del proyecto (Anton viene en el paquete)
+		const archivo = path.join(proyecto, 'fuentes', `${e.letra.replace(/\s+/g, '')}.ttf`);
+		if (LETRAS[e.letra] && fs.existsSync(archivo)) out.fuentes[e.letra] = archivo;
+	}
+	out.estilos['mi-estilo'] = tema;
+	out.estilo = 'mi-estilo';
+	if (e.voz) out.voces['mi-voz'] = e.voz;
+	out.__estiloPropio = {voz: e.voz ? 'mi-voz' : null, velocidad: ritmo.velocidad, estiloAnterior: cfg.estilo ?? 'datos-curiosos'};
+	return out;
+}

package/lib/estructura.mjs

@@ -43,8 +43,11 @@ export const REGLAS = [
 export const REGLAS_TEXTO = `Estructura (medida en videos virales; síguela):
 ${REGLAS.map((r, i) => `${i + 1}. ${r.regla}: ${r.como}`).join('\n')}`;
 
+import {revisarVoz, revisarZona} from './calidad.mjs';
+import {formulaDe, revisarFormula} from './formulas.mjs';
+
 const palabrasDe = (s) => String(s ?? '').trim().split(/\s+/).filter(Boolean);
-const GANCHOS = /^(¿|¡|imagina|y si|cómo|como se|si tu|si te|si un|qué pasaría|que pasaria|este es|esta es|esto es|nadie|nunca|todos|a \S+ |hay |tu |tú |te |tienes|cuando)/i;
+const GANCHOS = /^(¿|¡|imagina|la mayoría|la mayoria|y si|cómo|como se|si tu|si te|si un|qué pasaría|que pasaria|este es|esta es|esto es|nadie|nunca|todos|a \S+ |hay |tu |tú |te |tienes|cuando)/i;
 
 /**
  * Revisa la estructura de un video y devuelve consejos (no bloquea el render).
@@ -61,7 +64,8 @@ export function revisarEstructura(v, d) {
 	const primera = cuerpo[0];
 	const clasico = (v.estilo ?? 'datos-curiosos') === 'datos-curiosos';
 	// formato largo: explicador de maqueta (o `formato: 'largo'` en el video)
-	const largo = v.estilo === 'maqueta' || v.formato === 'largo';
+	const formula = formulaDe(v.formula);
+	const largo = v.estilo === 'maqueta' || v.formato === 'largo' || (formula?.duracion[1] ?? 0) > 90;
 
 	// 1) gancho
 	const dicho = String(primera.say ?? '').trim();
@@ -100,7 +104,7 @@ export function revisarEstructura(v, d) {
 
 	// 4) cierre
 	const fin = escenas.at(-1);
-	const pideAlgo = escenas.some((s) => s.type === 'eleccion') || (fin?.type === 'cta' && fin.pide) || /comenta|escribe|mándaselo|mandaselo|comparte|elige|parte 2|siguiente parte/i.test(cuerpo.at(-1)?.say ?? '');
+	const pideAlgo = escenas.some((s) => s.type === 'eleccion') || (fin?.type === 'cta' && fin.pide) || /comenta|escribe|mándaselo|mandaselo|envíaselo|enviaselo|comparte|elige|parte 2|siguiente parte|capítulo/i.test(cuerpo.at(-1)?.say ?? '');
 	if (!pideAlgo) add('cierre', 'idea', "El cierre solo pide seguir. Pide algo concreto: {type: 'cta', pide: 'comenta', palabra: 'PASO'}, pide: 'comparte' o una escena 'eleccion' (A o B).");
 
 	// 5) habla de tú
@@ -108,6 +112,11 @@ export function revisarEstructura(v, d) {
 	const n = palabrasDe(todo).length;
 	const tu = (todo.match(/\b(tú|tu|tus|te|ti|contigo|imagina|imaginas|tienes|eres|puedes|sabes|sabías|crees|conoces|harías|pagarías)\b/gi) ?? []).length;
 	if (n > 40 && tu === 0) add('tu', 'idea', 'No le habla al espectador ni una vez: una frase en segunda persona ("imagina que tú…") lo mete en la historia.');
+	// 6) lo propio de la fórmula del video (lib/formulas.mjs)
+	for (const t of revisarFormula(v)) add('formula', 'idea', t);
+	// 7) lo que no se ve a simple vista: la voz dijo lo del guion y nada queda bajo los botones de las apps
+	out.push(...revisarZona(v), ...revisarVoz(v, d));
+	// "envíaselo a…" también es un cierre que pide algo
 	return out;
 }
 

package/lib/formulas.mjs

@@ -0,0 +1,179 @@
+// Fórmulas de historia medidas en los videos de referencia (referencias/videos-ejemplo.md). Una sola fuente para:
+// el prompt de `morfeo guion` (la IA elige una o se le pide con --formula), `morfeo revisar` (consejos propios de cada
+// fórmula) y `morfeo formulas` (la lista). Cada una dice cómo arranca, cómo avanza, cómo cierra y qué piezas le quedan.
+
+/** @typedef {{id: string, nombre: string, para: string, esqueleto: string[], gancho: string, cierre: string, duracion: [number, number], estilos: string[], piezas: string, revisar?: (v: any, texto: string) => string[]}} Formula */
+
+const dice = (texto, re) => re.test(texto);
+
+/** @type {Formula[]} */
+export const FORMULAS = [
+	{
+		id: 'construiste',
+		nombre: 'Construiste un X',
+		para: 'explicar cómo funciona una obra, máquina o instalación (túnel, inodoro, portón eléctrico, semáforo)',
+		esqueleto: ['Arranca por lo obvio: "Si haces un hoyo en la montaña, tienes un túnel…"', 'Falla por algo concreto ("pero el techo plano se derrumba")', 'Lo arreglas con la pieza real ("le das forma de arco")', 'Repite falla → arreglo 4 a 7 veces; cada arreglo es una pieza nueva en pantalla', 'Remate: "¡Felicidades, construiste un túnel!"'],
+		gancho: '"Si a tu portón le pones un motor, ya no te bajas a abrir… pero no sabe cuándo parar."',
+		cierre: '"¡Felicidades, construiste X!" y "comenta qué construimos en el próximo".',
+		duracion: [90, 120],
+		estilos: ['maqueta', '3d'],
+		piezas: 'un solo mundo (Maqueta con corte de tierra), Aparece por pieza en su palabra, etiquetas 3D, rótulo paso con número, modo plano para ver por dentro',
+		revisar: (v, texto) => {
+			const out = [];
+			if (!dice(texto, /felicidades|construiste|inventaste|has (?:construido|inventado)/i)) out.push('Fórmula "construiste": cierra con "¡Felicidades, construiste X!" (es el remate que esperan).');
+			const pero = (texto.match(/\bpero\b/gi) ?? []).length;
+			if (pero < 3) out.push(`Fórmula "construiste": solo ${pero} "pero". La cadena falla → arreglo necesita 4–7 rondas ("…pero se derrumba, así que…").`);
+			return out;
+		},
+	},
+	{
+		id: 'recomendable',
+		nombre: 'Lo recomendable es X, y no [absurdo]',
+		para: 'humor con datos: consejos cotidianos contra la exageración más absurda (prensa de 500 t para un zancudo)',
+		esqueleto: ['"¿Sabías que para X lo recomendable es Y…"', '"…y no [la exageración con cifra]: [consecuencia absurda]"', 'Tres rondas iguales con objetos distintos (cifra en tarjeta cada vez)', 'Remate corto que vuelve al principio'],
+		gancho: '"¿Sabías que si quieres matar un zancudo, lo recomendable es usar la mano y no una prensa de 500 toneladas?"',
+		cierre: 'Remate de una línea ("La próxima, con cuchara") o "síguenos si quieres más así".',
+		duracion: [45, 60],
+		estilos: ['3d', 'datos-curiosos'],
+		piezas: 'subtítulo palabra con coloresClave, dato/chip con la cifra exagerada, sello para la consecuencia',
+		revisar: (v, texto) => ((texto.match(/\by no\b/gi) ?? []).length < 2 ? ['Fórmula "recomendable": repite "lo recomendable es… y no…" al menos 3 veces; la gracia está en el patrón.'] : []),
+	},
+	{
+		id: 'escalada',
+		nombre: 'Escalada absurda',
+		para: 'un objeto cotidiano que crece pieza por pieza porque cada solución causa otro problema (la mochila que termina con reactor)',
+		esqueleto: ['Problema cotidiano y su arreglo simple ("le pones dos ruedas")', '"Pero [alguien/algo] causa otro problema, así que le metes…"', 'Cada escena suma una pieza visible y más grande', 'Remate: "Felicidades, has inventado una mochila básica"'],
+		gancho: '"Tu mochila pesa más que tu abuela, así que le pones dos ruedas."',
+		cierre: '"Felicidades, has inventado [algo que ya existe]" y "envíaselo a tu amigo que…".',
+		duracion: [40, 55],
+		estilos: ['3d'],
+		piezas: 'Aparece (cae y rebota) por cada pieza en su palabra, Persona3D reaccionando, sello por golpe cómico',
+		revisar: (v, texto) => (!dice(texto, /así que|entonces/i) ? ['Fórmula "escalada": encadena con "así que…" / "entonces le…": cada arreglo provoca el siguiente.'] : []),
+	},
+	{
+		id: 'supervivencia',
+		nombre: 'Regla de supervivencia',
+		para: 'qué hacer ante un peligro con dos variantes que se confunden (oso negro / grizzly, medusa, rayo)',
+		esqueleto: ['"Si te pasa X: con uno haz A y con el otro nunca. Si te equivocas…"', 'Presenta el primero con cifras (peso, velocidad) y qué hacer', 'Presenta el segundo y por qué es al revés', 'Cómo distinguirlos (una sola seña visual)', 'Cierre en suspenso o pregunta'],
+		gancho: '"Si te ataca un oso, con uno tienes que hacerte el muerto, y con el otro, nunca."',
+		cierre: 'Suspenso ("porque cuando el próximo oso cargue contra ti…") o "comenta cuál sabías".',
+		duracion: [45, 60],
+		estilos: ['ilustrado', 'documental'],
+		piezas: 'chips de cifra pegados al animal, comparar/dividida A | B, contorno sobre la seña que los distingue',
+	},
+	{
+		id: 'experimento',
+		nombre: 'Experimento mental con contador',
+		para: 'dilemas y "¿qué pasa si…?" que se resuelven contando (un céntimo que se duplica, 10 años de un hábito)',
+		esqueleto: ['Dilema o pregunta con cifra ("¿Un millón ahora o un céntimo que se duplica 30 días?")', 'Casi todos eligen mal', 'Contador por días/años con saltos (Día 1, 7, 20…)', 'Giro en los últimos días', 'Resultado con número grande'],
+		gancho: '"Un millón de euros ahora mismo, o un céntimo que se duplica cada día durante 30 días."',
+		cierre: '"Así que ya sabes qué decir cuando alguien te pregunte" o pregunta A/B.',
+		duracion: [45, 60],
+		estilos: ['mesa', 'infografia', '3d'],
+		piezas: 'contador lcd, Pila que crece, calendario que avanza, rótulo pixel para el resultado',
+		revisar: (v, texto) => (!dice(texto, /\bd[ií]a\b|\baños?\b|\bmes(es)?\b/i) ? ['Fórmula "experimento": marca el tiempo en voz ("día siete…", "diez años después") y con un contador o calendario.'] : []),
+	},
+	{
+		id: 'misterio',
+		nombre: 'Misterio con giro',
+		para: 'historias reales o inventadas con un hecho raro que escala y se explica al final',
+		esqueleto: ['Hecho raro en una frase ("Un hombre se colaba cada noche y movía todo 2,5 cm")', 'Escala por días ("DÍA 8", "DÍA 12") con la tensión de quien lo vive', 'Consecuencia (venden la casa, llaman a la policía)', 'Giro final que reordena todo (el comprador era él)'],
+		gancho: '"Un hombre se colaba cada noche en una casa y movía cada objeto dos centímetros a la izquierda."',
+		cierre: 'El giro es el cierre; nada de "sígueme" largo.',
+		duracion: [50, 65],
+		estilos: ['historia', 'ilustrado'],
+		piezas: 'siluetas, calendario o tarjeta "DÍA 8", vigilancia, medida para los centímetros',
+	},
+	{
+		id: 'demuestralo',
+		nombre: 'Te lo demuestro',
+		para: 'algo que el espectador puede probar con su cuerpo o su casa en ese momento',
+		esqueleto: ['"Hay algo que tu cuerpo no puede hacer y te lo voy a demostrar"', 'Instrucciones paso a paso al espectador (pon, dobla, levanta)', 'Lo que pasa ("¿No sube?")', 'Explicación con rayos X / plano', '"Tu cuerpo viene así de fábrica"'],
+		gancho: '"Hay un dedo de tu mano que no puedes levantar, y te lo voy a demostrar."',
+		cierre: '"Envíaselo a un amigo y que lo intente."',
+		duracion: [30, 45],
+		estilos: ['ilustrado', 'explicativo'],
+		piezas: 'modo rayosx en la explicación, trazo/contorno sobre la parte, cierre comparte',
+		revisar: (v) => (!(v.scenes ?? []).some((s) => s.modo) ? ['Fórmula "demuéstralo": la explicación luce con `modo: \'rayosx\'` en la palabra donde se ve "por dentro".'] : []),
+	},
+	{
+		id: 'mito',
+		nombre: 'Mito desmentido con comparación',
+		para: 'creencias comunes que tienen truco (la cinta de correr "miente", el microondas, la sal)',
+		esqueleto: ['Afirmación tajante ("La cinta te miente")', 'Por qué (la física o la biología en una frase)', 'La prueba (estudio o medida)', 'Comparación lado a lado', 'Matiz honesto', 'CTA a quien cree el mito'],
+		gancho: '"Diez kilómetros en la cinta y diez en la calle: mismo reloj, y no hiciste lo mismo."',
+		cierre: '"Envíaselo a ese amigo que dice que…"',
+		duracion: [50, 65],
+		estilos: ['infografia', 'explicativo'],
+		piezas: 'dividida A | B, medidor, barras, sellos "TE MIENTE" / "PILLADO", modo plano',
+	},
+	{
+		id: 'roast',
+		nombre: 'Roast con analogía animal',
+		para: 'conductas de la gente explicadas con la biología de un animal (el amigo tacaño y el pavo real)',
+		esqueleto: ['Pregunta provocadora sobre un conocido ("¿Por qué tu amigo el rata…?")', '"Es lo mismo que le pasa a un [animal]"', 'Explicación biológica con imágenes del animal', 'Vuelta al amigo con la analogía', 'CTA para mandárselo a ese amigo'],
+		gancho: '"¿Por qué tu amigo el rata no te invita ni un café, pero a su novia le paga las vacaciones?"',
+		cierre: '"Envíaselo a tu amigo el rata y que esta vez el café lo pague él."',
+		duracion: [45, 60],
+		estilos: ['ilustrado', 'mesa'],
+		piezas: 'mismos objetos que vuelven (cartera, café), lugares distintos por tramo, cierre comparte',
+		revisar: (v) => {
+			const cta = (v.scenes ?? []).find((s) => s.type === 'cta');
+			return cta && cta.pide !== 'comparte' ? ['Fórmula "roast": cierra con `pide: \'comparte\'` y un destinatario concreto ("tu amigo el rata").'] : [];
+		},
+	},
+	{
+		id: 'serie',
+		nombre: 'Serie interactiva (elige tú)',
+		para: 'historias por capítulos donde el público decide qué pasa (llamadas del futuro, vuelos perdidos)',
+		esqueleto: ['Recuento de lo que votaron ("La mayoría de ustedes votó…") si no es el capítulo 1', 'El capítulo en tiempo real: hora en pantalla, teléfono, noticias', 'Escalada hasta una decisión', 'Cliffhanger con dos opciones A/B', '"Comenta tu opción; la más votada gana. Capítulo 3 mañana 15:30"'],
+		gancho: '"Anoche te llamó tu propio número y te dijo que no tomaras el metro."',
+		cierre: 'Capa `capitulo` con las dos opciones y el horario, o escena `eleccion`.',
+		duracion: [70, 115],
+		estilos: ['historia', 'serie'],
+		piezas: 'serie (pastilla fija), recuento, bloqueo, llamada, noticia, vigilancia, capitulo',
+		revisar: (v) => {
+			const ultima = (v.scenes ?? []).at(-1);
+			const tieneFinal = (v.scenes ?? []).some((s) => s.type === 'eleccion' || (s.capas ?? []).some((c) => c.tipo === 'capitulo'));
+			const out = [];
+			if (!tieneFinal) out.push('Fórmula "serie": termina con una decisión A/B (capa `capitulo` o escena `eleccion`): es lo que trae comentarios.');
+			if (!v.serie) out.push("Fórmula \"serie\": pon `serie: 'MI SERIE · CAP. 2'` para la pastilla fija arriba.");
+			if (ultima && ultima.type === 'cta' && !ultima.pide) out.push('Fórmula "serie": el cierre debe pedir que comenten su opción, no solo "sígueme".');
+			return out;
+		},
+	},
+	{
+		id: 'biografia',
+		nombre: 'Biografía con secreto',
+		para: 'la vida de una persona o empresa contada año por año, con un escándalo o secreto como gancho',
+		esqueleto: ['Gancho de escándalo ("Al jefe no lo descubrió su esposa: lo descubrieron los espías")', 'Origen: lugar y año (globo con pin)', 'Ascenso año por año (tarjetas de año, cintillos con nombres)', 'El secreto con pruebas (documentos, vigilancia)', 'Final abierto'],
+		gancho: '"Al jefe de [empresa] no lo descubrió su esposa: lo descubrieron los espías."',
+		cierre: 'Final abierto ("Le dijeron que no.") o "sígueme para la parte 2".',
+		duracion: [90, 180],
+		estilos: ['documental', '3d'],
+		piezas: 'lugares (un set por época), tierra con pin, fecha, cintillo, calendario, vigilancia, ficha',
+		revisar: (v) => (!v.lugares ? ['Fórmula "biografía": usa `lugares` (un set por época o sitio) y `lugar` por escena: un solo fondo se siente pobre en 2–3 minutos.'] : []),
+	},
+];
+
+export const IDS_FORMULA = FORMULAS.map((f) => f.id);
+export const formulaDe = (id) => FORMULAS.find((f) => f.id === id) ?? null;
+
+/** Texto de las fórmulas para el prompt de la IA. */
+export function formulasParaIA(id) {
+	const lista = id ? [formulaDe(id)].filter(Boolean) : FORMULAS;
+	return lista
+		.map(
+			(f) =>
+				`### ${f.id}: ${f.nombre}\nPara: ${f.para}.\nEsqueleto:\n${f.esqueleto.map((p, i) => `  ${i + 1}. ${p}`).join('\n')}\nGancho de ejemplo: ${f.gancho}\nCierre: ${f.cierre}\nDuración: ${f.duracion[0]}–${f.duracion[1]} s.`,
+		)
+		.join('\n\n');
+}
+
+/** Consejos propios de la fórmula del video (`formula: 'construiste'`). */
+export function revisarFormula(v) {
+	const f = formulaDe(v?.formula);
+	if (!f?.revisar) return [];
+	const texto = (v.scenes ?? []).map((s) => s.say ?? '').join(' ');
+	return f.revisar(v, texto);
+}

package/lib/guion.mjs

@@ -1,5 +1,6 @@
 // Guiones: de un tema (la IA escribe todo) o de tu propio texto (la IA lo convierte en escenas,
 // o sin IA: una escena por frase). El resultado es un video listo para editar en videos/<id>.json.
+import {FORMULAS, IDS_FORMULA, formulaDe, formulasParaIA} from './formulas.mjs';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -120,8 +121,17 @@ Además, en cualquier escena:
 Varía los tipos. "at", "check" y "en" deben ser palabras que aparezcan tal cual en "say".
 No escribas la escena de cierre: va en "cierre" (lo que pide al final: "comenta" una "palabra", "comparte" con "a" quién se lo mandan, o "sigue"), con su "say".
 
+- "rotulo_estilo": cómo se ve el rótulo: "sello" (sello de goma inclinado para un golpe: "¡SIN LUZ!", "¡TE MIENTE!"),
+  "paso" (titular de paso con número en "rotulo_paso", para explicar en orden), "pixel" (caja de videojuego para
+  resultados: "RESULTADO", "-20% RIESGO"), "pastilla" (aviso: "¡CUIDADO!") o null (el del estilo).
+- "modo": "rayosx" (ver por dentro: cuerpo, máquina), "plano" (cómo está hecho) u "holograma" (datos, cerebro) en la
+  escena que lo explica, con "modo_en" = la palabra donde cambia; null en las demás. Úsalo en 1–3 escenas como máximo.
+
 ${REGLAS_TEXTO}
 
+Fórmulas de historia (elige la que mejor le quede al tema y escribe en "formula" su id; síguela de principio a fin):
+${formulasParaIA()}
+
 Diccionario de recursos por tema (usa estas palabras en "recurso"):
 ${Object.entries(listaTemas()).map(([t, v]) => `- ${t}: ${v.join(', ')}`).join('\n')}`;
 
@@ -153,10 +163,14 @@ export async function esquemaMotor() {
 		pregunta: z.string().nullable(),
 		opciones: z.array(z.object({texto: z.string(), sub: z.string(), objeto: z.enum(OBJETOS).nullable(), emoji: z.string().nullable()})).nullable(),
 		rotulo: z.string().nullable(),
+		rotulo_estilo: z.enum(['sello', 'paso', 'pixel', 'pastilla']).nullable(),
+		rotulo_paso: z.number().nullable(),
+		modo: z.enum(['rayosx', 'plano', 'holograma']).nullable(),
+		modo_en: z.string().nullable(),
 		claves: z.array(z.string()).nullable(),
 	});
 	const cierre = z.object({pide: z.enum(['comenta', 'comparte', 'sigue']), say: z.string(), palabra: z.string().nullable(), a: z.string().nullable()});
-	return z.object({id: z.string(), title: z.string(), music: z.enum(MUSICAS), scenes: z.array(escena), cierre});
+	return z.object({id: z.string(), title: z.string(), formula: z.enum(IDS_FORMULA), music: z.enum(MUSICAS), descripcion: z.string(), tags: z.array(z.string()), hooks: z.array(z.string()), scenes: z.array(escena), cierre});
 }
 
 /** De la salida de la IA (motor de capas) al formato de escenas de morfeo. */
@@ -165,6 +179,14 @@ export function aEscenaMotor(e, conImagenes) {
 	if (e.show && e.show !== e.say) out.show = e.show;
 	const si = (k, v) => v != null && v !== '' && (out[k] = v);
 	si('rotulo', e.rotulo);
+	if (e.rotulo && e.rotulo_estilo) {
+		out.rotuloEstilo = e.rotulo_estilo;
+		if (e.rotulo_estilo === 'paso' && e.rotulo_paso != null) out.rotuloPaso = e.rotulo_paso;
+	}
+	if (e.modo) {
+		out.modo = e.modo;
+		si('modoEn', e.modo_en);
+	}
 	if (e.claves?.length) out.claves = e.claves;
 	switch (e.type) {
 		case 'titular':
@@ -244,6 +266,51 @@ export function aEscena(e) {
 	return out;
 }
 
+/**
+ * Investiga el tema en la web antes de escribir (búsqueda del servidor de Claude): devuelve notas con cada dato y su
+ * fuente, y la lista de fuentes que de verdad se consultaron (las URLs de los resultados de búsqueda citados).
+ * @returns {Promise<{notas: string, fuentes: {texto: string, url: string}[]}>}
+ */
+export async function investigar(client, Anthropic, tema, {idioma = 'español de México', modelo = MODELO_GUION, log = () => {}} = {}) {
+	const messages = [
+		{
+			role: 'user',
+			content: `Investiga para un video corto vertical sobre: ${tema}
+
+Busca en la web y junta 8 a 12 datos concretos, sorprendentes y verificables (cifras, fechas, nombres, lugares), cada uno
+con la fuente donde lo leíste (nombre del medio o institución y URL). Prefiere fuentes primarias u oficiales. Si dos
+fuentes no coinciden, dilo. No inventes nada que no esté en una fuente.
+Responde en ${idioma} con una lista: "- dato · fuente (URL)".`,
+		},
+	];
+	const vistas = new Map();
+	let texto = '';
+	// la búsqueda corre en el servidor; si el turno se pausa (pause_turn), se reenvía para que continúe
+	for (let vuelta = 0; vuelta < 6; vuelta++) {
+		const res = await client.messages.create({
+			model: modelo,
+			max_tokens: 16000,
+			tools: [{type: 'web_search_20260209', name: 'web_search', max_uses: 8}],
+			messages,
+		});
+		for (const b of res.content) {
+			if (b.type === 'web_search_tool_result' && Array.isArray(b.content)) for (const r of b.content) if (r.url) vistas.set(r.url, r.title ?? r.url);
+			if (b.type === 'text') {
+				texto += b.text;
+				for (const c of b.citations ?? []) if (c.url) vistas.set(c.url, c.title ?? vistas.get(c.url) ?? c.url);
+			}
+		}
+		if (res.stop_reason === 'refusal') throw new ErrorMorfeo('Claude no quiso investigar ese tema.');
+		if (res.stop_reason !== 'pause_turn') break;
+		log('    (sigue buscando…)');
+		messages.push({role: 'assistant', content: res.content});
+	}
+	if (!texto.trim()) throw new ErrorMorfeo('La investigación no devolvió datos; intenta otra vez o sin --investigar.');
+	// solo las fuentes que aparecen en las notas (las que de verdad respaldan un dato)
+	const fuentes = [...vistas].filter(([url]) => texto.includes(url) || texto.includes(new URL(url).hostname)).map(([url, titulo]) => ({texto: titulo, url}));
+	return {notas: texto.trim(), fuentes: fuentes.length ? fuentes : [...vistas].slice(0, 8).map(([url, titulo]) => ({texto: titulo, url}))};
+}
+
 /**
  * Pide a Claude un video completo.
  * @param {{tema?: string, texto?: string, idioma?: string, duracion?: number, tono?: string, estilo?: string, imagenes?: boolean, voz?: any, modelo?: string}} o
@@ -261,14 +328,33 @@ export async function guionConIA(o) {
 		throw new ErrorMorfeo('Falta la dependencia @anthropic-ai/sdk (npm install @anthropic-ai/sdk zod)');
 	}
 	const client = new Anthropic();
+	// --investigar: primero los datos con su fuente (búsqueda web), luego el guion se escribe solo con esos datos
+	let investigacion = null;
+	if (o.investigar && !o.texto) {
+		(o.log ?? console.log)('Investigando el tema en la web (cada dato con su fuente)...');
+		try {
+			investigacion = await investigar(client, Anthropic, o.tema, {idioma: o.idioma ?? 'español de México', modelo: o.modelo ?? MODELO_GUION, log: o.log ?? console.log});
+		} catch (e) {
+			if (e instanceof ErrorMorfeo) throw e;
+			if (e instanceof Anthropic.APIError) throw new ErrorMorfeo(`La búsqueda web falló (${e.status}): ${e.message}. Intenta sin --investigar.`);
+			throw e;
+		}
+	}
 	const idioma = o.idioma ?? 'español de México';
-	const pedido = o.texto
+	const pedidoBase = o.texto
 		? `Convierte este guion en escenas. Respeta su contenido y su orden; puedes partir frases largas.\n\n<guion>\n${o.texto}\n</guion>`
 		: `Escribe un video sobre: ${o.tema}`;
+	const pedido = investigacion
+		? `${pedidoBase}\n\nUsa SOLO estos datos investigados (no agregues cifras que no estén aquí):\n<investigacion>\n${investigacion.notas}\n</investigacion>`
+		: pedidoBase;
 	// ~45 s por defecto: los videos de referencia rondan el minuto y ninguna idea pasa de ~5 s (lib/estructura.mjs)
-	const dur = o.duracion ?? 45;
+	const forzada = o.formula ? formulaDe(o.formula) : null;
+	if (o.formula && !forzada) throw new ErrorMorfeo(`La fórmula "${o.formula}" no existe. Opciones: ${IDS_FORMULA.join(', ')}`);
+	// con fórmula, la duración es la de sus videos de referencia (el punto medio de su rango)
+	const dur = o.duracion ?? (forzada ? Math.round((forzada.duracion[0] + forzada.duracion[1]) / 2) : 45);
 	const extra = [`Idioma: ${idioma}.`, `Duración aproximada: ${dur} segundos (unas ${Math.round(dur / 4)} escenas de 3 a 5 segundos).`];
 	if (o.tono) extra.push(`Tono: ${o.tono}.`);
+	if (forzada) extra.push(`Fórmula: usa "${forzada.id}" (${forzada.nombre}) y su esqueleto tal cual.`);
 	const motor = o.estilo && o.estilo !== 'datos-curiosos';
 	if (motor) extra.push(`Estilo visual: ${o.estilo}.${o.imagenes ? ' Se pueden generar ilustraciones (usa imagen_ia en las escenas capas).' : ' No hay ilustraciones: usa emoji en las escenas capas.'}`);
 
@@ -278,7 +364,7 @@ export async function guionConIA(o) {
 			model: o.modelo ?? MODELO_GUION,
 			max_tokens: 16000,
 			system: motor ? INSTRUCCIONES_MOTOR : INSTRUCCIONES,
-			messages: [{role: 'user', content: `${pedido}\n\n${extra.join('\n')}\nEn "id" pon un identificador corto en minúsculas sin espacios. En "title" el título para publicar (con un emoji). En "music" el estilo de música que mejor le quede.`}],
+			messages: [{role: 'user', content: `${pedido}\n\n${extra.join('\n')}\nEn "id" pon un identificador corto en minúsculas sin espacios. En "title" el título para publicar (con un emoji). En "music" el estilo de música que mejor le quede. En "descripcion" el texto del post (1–2 frases). En "tags" 3–5 etiquetas sin #. En "hooks" 3 primeras frases alternativas al gancho, distintas entre sí, para probar otra versión.`}],
 			output_config: {format: zodOutputFormat(motor ? await esquemaMotor() : await esquema())},
 		});
 	} catch (e) {
@@ -295,7 +381,7 @@ export async function guionConIA(o) {
 		const scenes = g.scenes.map((e) => aEscenaMotor(e, !!o.imagenes));
 		const c = g.cierre;
 		const cta = !c || c.pide === 'sigue' ? {type: 'cta', ...(c?.say ? {say: c.say} : {})} : {type: 'cta', pide: c.pide, say: c.say, ...(c.palabra ? {palabra: c.palabra} : {}), ...(c.a ? {a: c.a} : {})};
-		return {id: slug(g.id || g.title), video: {estilo: o.estilo, title: g.title, voice: o.voz ?? 'em_alex', music: g.music, scenes: [...scenes, cta]}};
+		return {id: slug(g.id || g.title), video: {estilo: o.estilo, formula: forzada?.id ?? g.formula, title: g.title, descripcion: g.descripcion, tags: g.tags, hooks: g.hooks, ...(investigacion?.fuentes.length ? {fuentes: investigacion.fuentes} : {}), voice: o.voz ?? 'em_alex', music: g.music, scenes: [...scenes, cta]}};
 	}
 	const scenes = g.scenes.map(aEscena);
 	if (scenes[0]?.type !== 'title') scenes.unshift({type: 'title', say: scenes[0]?.say ?? g.title, rows: [[g.title.toUpperCase().slice(0, 14), '#FFD400', 200]], icon: 'question'});

package/lib/hoja.mjs

@@ -1,6 +1,7 @@
 // `morfeo hoja <id>`: hoja de contacto (PNG con cuadros repartidos en el tiempo) para revisar un video de un vistazo.
 // El ffmpeg que trae Remotion viene recortado (sin los filtros `tile` ni `fps`), así que cada cuadro se pide como
 // PNG sin predicción por una tubería y la hoja se arma aquí con zlib.
+import {ZONAS} from './calidad.mjs';
 import {spawnSync} from 'node:child_process';
 import fs from 'node:fs';
 import {createRequire} from 'node:module';
@@ -62,10 +63,11 @@ function leerPng(b, w, h) {
 }
 
 /**
- * @param {{video: string, salida?: string, cols?: number, filas?: number, desde?: number, hasta?: number, ancho?: number}} op
+ * @param {{video: string, salida?: string, cols?: number, filas?: number, desde?: number, hasta?: number, ancho?: number, zona?: boolean}} op
+ *   zona: pinta en rojo lo que tapan los botones de TikTok/Reels/Shorts
  * @returns {string} ruta del PNG
  */
-export function hoja({video, salida, cols = 5, filas = 3, desde = 0, hasta, ancho = 216}) {
+export function hoja({video, salida, cols = 5, filas = 3, desde = 0, hasta, ancho = 216, zona = false}) {
 	// rutas absolutas: ffmpeg corre desde la carpeta de sus DLL, así que una ruta relativa no se encontraría
 	video = path.resolve(video);
 	if (salida) salida = path.resolve(salida);
@@ -87,6 +89,19 @@ export function hoja({video, salida, cols = 5, filas = 3, desde = 0, hasta, anch
 		const r = spawnSync(ffmpeg, ['-v', 'error', '-ss', t.toFixed(3), '-i', video, '-frames:v', '1', '-vf', `scale=${w}:${h}`, '-f', 'image2pipe', '-c:v', 'png', '-pred', 'none', '-pix_fmt', 'rgb24', '-'], {maxBuffer: 64 * 1024 * 1024, cwd});
 		if (r.status !== 0 || !r.stdout?.length) continue;
 		const px = leerPng(r.stdout, w, h);
+		if (zona) {
+			// tinte rojo en las zonas que tapan las apps (escala de 1080×1920 al tamaño del cuadro)
+			const ex = w / 1080;
+			const ey = h / 1920;
+			for (const z of ZONAS)
+				for (let y = Math.floor(z.y0 * ey); y < Math.min(h, Math.ceil(z.y1 * ey)); y++)
+					for (let x = Math.floor(z.x0 * ex); x < Math.min(w, Math.ceil(z.x1 * ex)); x++) {
+						const k = (y * w + x) * 3;
+						px[k] = Math.round(px[k] * 0.55 + 255 * 0.45);
+						px[k + 1] = Math.round(px[k + 1] * 0.55);
+						px[k + 2] = Math.round(px[k + 2] * 0.55);
+					}
+		}
 		const x0 = (i % cols) * w;
 		const y0 = Math.floor(i / cols) * h;
 		for (let y = 0; y < h; y++) px.copy(lienzo, (y0 + y) * (1 + W * 3) + 1 + x0 * 3, y * w * 3, (y + 1) * w * 3);

package/lib/nuevo-video.mjs

@@ -5,7 +5,14 @@ import path from 'node:path';
 import {ErrorMorfeo} from './config.mjs';
 import {PAQUETE} from './entorno.mjs';
 
-export const LOOKS = ['2d', '3d'];
+/** Bases disponibles: cada carpeta de bases/ con un guion.mjs (y un Mundo.tsx si lleva mundo propio). */
+export const LOOKS = (() => {
+	try {
+		return fs.readdirSync(path.join(PAQUETE, 'bases')).filter((d) => fs.existsSync(path.join(PAQUETE, 'bases', d, 'guion.mjs'))).sort();
+	} catch {
+		return ['2d', '3d'];
+	}
+})();
 
 /** "mi-video_2" -> "MundoMiVideo2" */
 export const nombreComponente = (id) =>
@@ -41,7 +48,7 @@ export function registrarEnConfig(texto, nombre, ruta) {
 
 /**
  * @param {{proyecto: string, id: string, look?: string, carpetaGuiones?: string}} o
- * @returns {{guion: string, escena: string, componente: string}}
+ * @returns {{guion: string, escena: string | null, componente: string | null}}
  */
 export function nuevoVideo({proyecto, id, look = '2d', carpetaGuiones}) {
 	if (!id || !/^[a-z0-9][a-z0-9-_]*$/i.test(id)) throw new ErrorMorfeo('Dame un id corto sin espacios:  npx morfeo nuevo-video mi-video --look 2d');
@@ -52,12 +59,14 @@ export function nuevoVideo({proyecto, id, look = '2d', carpetaGuiones}) {
 	const dirGuiones = carpetaGuiones ?? path.join(proyecto, 'guiones');
 	const guion = path.join(dirGuiones, `${id}.mjs`);
 	const escena = path.join(proyecto, 'escenas', `${componente}.tsx`);
-	for (const f of [guion, escena]) if (fs.existsSync(f)) throw new ErrorMorfeo(`Ya existe ${path.relative(proyecto, f)}; elige otro id.`);
+	for (const f of [guion, escena]) if (f && fs.existsSync(f)) throw new ErrorMorfeo(`Ya existe ${path.relative(proyecto, f)}; elige otro id.`);
 	const base = path.join(PAQUETE, 'bases', look);
 	const poner = (s) => s.replaceAll('__ID__', id).replaceAll('__COMPONENTE__', componente);
 	fs.mkdirSync(dirGuiones, {recursive: true});
 	fs.mkdirSync(path.dirname(escena), {recursive: true});
 	fs.writeFileSync(guion, poner(fs.readFileSync(path.join(base, 'guion.mjs'), 'utf8')));
+	// bases sin mundo propio (solo capas): no hay componente que copiar ni registrar
+	if (!fs.existsSync(path.join(base, 'Mundo.tsx'))) return {guion, escena: null, componente: null};
 	fs.writeFileSync(escena, poner(fs.readFileSync(path.join(base, 'Mundo.tsx'), 'utf8')));
 	const nuevo = registrarEnConfig(fs.readFileSync(config, 'utf8'), componente, `./escenas/${componente}.tsx`);
 	if (nuevo) fs.writeFileSync(config, nuevo);

package/lib/palabras.mjs

@@ -35,7 +35,7 @@ function momentosDe(x, ruta, out) {
 		if (p) out.push([`${ruta}.${k}`, p]);
 	}
 	// lo que vive dentro de una capa: sus capas, su capa repetida, cambios, poses, items, líneas, movimientos
-	for (const k of ['capas', 'capa', 'cambios', 'poses', 'items', 'lineas', 'mover', 'escalar', 'opciones', 'capasPantalla'])
+	for (const k of ['capas', 'capa', 'cambios', 'poses', 'items', 'lineas', 'mover', 'escalar', 'opciones', 'capasPantalla', 'hitos', 'notificaciones'])
 		if (x[k] != null) momentosDe(x[k], `${ruta}.${k}`, out);
 }
 
@@ -70,7 +70,7 @@ export function revisarPalabras(v, d) {
 				avisos.push(`escena ${i + 1}, ${ruta}: "${p}" no está en ${s.show ? 'el subtítulo (`show`)' : 'lo que dice la voz'} ("${texto}"); se usará la mitad de la frase`);
 	});
 	// hud y mundo usan las palabras de todo el video
-	for (const [k, lista] of [['hud', v.hud], ['mundo', v.mundo]]) {
+	for (const [k, lista] of [['hud', v.hud], ['mundo', v.mundo], ...Object.entries(v.lugares ?? {}).map(([n, l]) => [`lugares.${n}`, l])]) {
 		const momentos = [];
 		momentosDe(lista ?? [], k, momentos);
 		for (const [ruta, p] of momentos) if (!laDice(p, todas)) avisos.push(`${ruta}: "${p}" no aparece en ninguna escena`);