morfeo 0.6.7 → 0.7.0

package/README.md

@@ -58,8 +58,16 @@ npx morfeo render
 | `morfeo guion "tema"` | Claude escribe un video completo en `guiones/<id>.json` (`--estilo documental`, `--imagenes`) |
 | `morfeo estilos` | Lista los estilos visuales |
 | `morfeo guion --desde guion.txt` | Convierte tu texto en escenas (con IA, o `--sin-ia`: una escena por frase) |
+| `morfeo skills` | Instala o actualiza las guías para tu IA (guion, animación, 3D) en `.claude/skills/` |
 | `morfeo instalar` / `doctor` | Prepara o revisa la computadora |
 
+## Skills para tu IA
+
+El paquete trae cuatro guías de oficio para Claude Code, Codex u otra IA: `morfeo-video` (la ruta completa),
+`morfeo-guion` (ganchos, historia ordenada por retención, cierre), `morfeo-animacion` (tiempos, curvas, escalonado,
+cámara) y `morfeo-3d` (luz, materiales, encuadre). `morfeo nuevo` las deja en `.claude/skills/` y `morfeo skills` las
+pone al día; cualquier IA puede leerlas en `node_modules/morfeo/skills/`, como indica el `AGENTS.md` del proyecto.
+
 ## Un video
 
 ```js

package/bin/morfeo.mjs

@@ -43,6 +43,8 @@ Guiones
       --formula <id>      una fórmula de historia (construiste, serie, mito, misterio…)
       --investigar        busca cada dato en la web con su fuente antes de escribir (van al texto del post)
   formulas              Las fórmulas de historia medidas en videos de referencia
+  skills                Instala o actualiza las guías para tu IA (guion, animación y 3D) en .claude/skills/
+      --lista             solo las muestra
   estilo                Abre una página para crear tu estilo: nombre, siglas, colores, letra, voz, ritmo y cierre
       --estilo documental   estilo visual (por defecto, el del proyecto)
       --imagenes            pide ilustraciones con IA (necesita OPENAI_API_KEY)
@@ -240,6 +242,16 @@ Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]
 			console.log('Úsala:  npx morfeo guion "tu tema" --formula construiste   (o formula: \'construiste\' en el guion para que `revisar` la revise)');
 			return;
 		}
+		case 'skills':
+		case 'skill': {
+			const {listaSkills, instalarSkills} = await import('../lib/skills.mjs');
+			const lista = listaSkills();
+			for (const s of lista) console.log(`${s.nombre.padEnd(18)} ${s.descripcion.split('. ')[0]}.`);
+			if (op.lista) return;
+			const hechas = instalarSkills(proyecto);
+			console.log(`\n${hechas.length} skills copiadas a .claude/skills/ (Claude Code las usa solas). Otras IA las leen en node_modules/morfeo/skills/, como indica AGENTS.md.`);
+			return;
+		}
 		case 'guion':
 		case 'script':
 			return guion(pos, op, proyecto);
@@ -320,6 +332,8 @@ async function nuevo(carpeta, op) {
 	// dos videos de ejemplo con mundo y la estructura completa (los mismos que `morfeo nuevo-video`)
 	const {nuevoVideo} = await import('../lib/nuevo-video.mjs');
 	for (const look of ['2d', '3d']) nuevoVideo({proyecto: destino, id: `ejemplo-${look}`, look});
+	// las guías para la IA (guion, animación, 3D), donde Claude Code las encuentra
+	(await import('../lib/skills.mjs')).instalarSkills(destino);
 	console.log(`Proyecto creado en ${carpeta}/\n\nCon tu IA: abre la carpeta en Claude Code o Codex y escribe «Configúrame»; luego «Hazme un video sobre…».\n\nA mano:\n  cd ${carpeta}\n  npm install\n  npx morfeo instalar     (solo la primera vez en esta computadora)\n  npx morfeo estilo       (tu nombre, colores, letra y voz)\n  npx morfeo render`);
 }
 

package/lib/estructura.mjs

@@ -27,13 +27,14 @@
 
 /** Las reglas, en el orden en que se le explican a la IA y a quien escribe un guion. */
 export const REGLAS = [
-	{id: 'gancho', regla: 'Gancho en los primeros 2 segundos', como: 'La primera frase pone al espectador dentro ("Imagina que…", "¿Y si tu…?", "Si tu…") o suelta una cifra o situación imposible. El sujeto ya está en pantalla desde el cuadro 1. Nada de títulos, logos ni "hoy te voy a contar".'},
+	{id: 'gancho', regla: 'Gancho en los primeros 2 segundos', como: 'La primera frase pone al espectador dentro ("Imagina que…", "¿Y si tu…?", "Si tu…") o suelta una cifra o situación imposible. El sujeto ya está en pantalla desde el cuadro 1. Nada de títulos, logos ni "hoy te voy a contar". Imagen, voz y rótulo dicen lo mismo y se entienden sin sonido; lo que promete el gancho, el video lo cumple.'},
+	{id: 'reserva', regla: 'Varios ganchos, no uno', como: 'Escribe de 6 a 10 de arquetipos distintos (cifra imposible, pregunta directa, contradicción, hallazgo, experimento, "este es X, pero…", error común), elige el mejor y deja 3 de reserva, cada uno de un arquetipo distinto al principal, en `hooks`.'},
 	{id: 'tu', regla: 'Habla de tú', como: 'Segunda persona y presente: "te despiertas", "abres la puerta". Si es una historia, un nombre propio en la primera frase ("Este es Alberto").'},
 	{id: 'ritmo', regla: 'Algo nuevo cada 2–4 segundos', como: 'Escenas de 2 a 5 s de voz (una idea por escena). Si la escena dura más, que algo entre a media frase (un dato, una etiqueta, un movimiento de cámara).'},
 	{id: 'pregunta', regla: 'Pregunta antes de revelar', como: 'Antes de cada dato fuerte, la pregunta que el espectador se haría ("¿Cuánto subió?"); la respuesta llega en la escena siguiente con un número que cuenta o un golpe visual.'},
 	{id: 'rotulo', regla: 'Texto en dos niveles', como: 'El subtítulo dice lo que se oye; un rótulo grande y corto (2–4 palabras) resume el momento: "¿CUÁNTO SUBIÓ?", "SALIR DE CASA", "DÍA 21".'},
 	{id: 'etiquetas', regla: 'Datos pegados a las cosas', como: 'Nombres y cifras junto a lo que señalan (nombre de personaje con su rol, "▶ acción", "57 toneladas" junto a la ballena), no en un letrero aparte.'},
-	{id: 'escalada', regla: 'Que suba la apuesta', como: 'Cada escena más grave, más grande o más rara que la anterior; lo más fuerte cerca del final, no al principio.'},
+	{id: 'escalada', regla: 'Que suba la apuesta', como: 'Cada escena más grave, más grande o más rara que la anterior; lo más fuerte (el pago: la respuesta a la pregunta del gancho) cerca del final, no al principio. Hacia la mitad, un giro que contradiga lo que ya se daba por hecho.'},
 	{id: 'cierre', regla: 'Cierre con una acción concreta', como: 'Pide algo fácil y específico: elegir A o B en comentarios, escribir una palabra ("escribe PASO"), mandárselo a alguien ("mándaselo al que dice que…") o esperar la parte 2. "Sígueme" solo no basta.'},
 	{id: 'bucle', regla: 'Final que conecta con el inicio', como: 'La última frase puede regresar a la primera imagen o dejar una pregunta abierta, para que se vuelva a ver.'},
 	{id: 'duracion', regla: 'Entre 30 y 65 segundos (o 90–130 en maqueta)', como: 'La mayoría de los de referencia dura ~1 minuto. Más de 75 s solo si es una serie, una historia o un explicador de maqueta (estilo maqueta: 90–130 s con un corte de cámara cada 2–3 s dentro del mismo mundo).'},
@@ -46,8 +47,9 @@ ${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 normal = (s) => String(s ?? '').toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^a-z0-9ñ ]+/g, ' ').replace(/\s+/g, ' ').trim();
 const palabrasDe = (s) => String(s ?? '').trim().split(/\s+/).filter(Boolean);
-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;
+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|dentro|llevas|f[ií]jate|mira |jugu[eé]|prob[eé]|encontr[eé])/i;
 
 /**
  * Revisa la estructura de un video y devuelve consejos (no bloquea el render).
@@ -78,6 +80,13 @@ export function revisarEstructura(v, d) {
 		add('gancho', 'aviso', 'El video abre con un letrero sin imagen. En los videos de referencia el sujeto ya está en pantalla desde el primer cuadro.');
 	if (/^(hola|hoy|bienvenid|en este video|te voy a)/i.test(dicho)) add('gancho', 'aviso', 'No abras presentando ("Hoy te voy a contar…"): entra directo a la situación.');
 
+	// 1b) ganchos de reserva: tres, y que no sean el principal con otras palabras
+	const reserva = (v.hooks ?? []).filter((h) => typeof h === 'string' && h.trim());
+	const arranque = (x) => normal(x).split(' ').slice(0, 3).join(' ');
+	if (reserva.length < 3) add('reserva', 'idea', `Hay ${reserva.length} gancho${reserva.length === 1 ? '' : 's'} de reserva en \`hooks\`: deja 3, de arquetipos distintos (cifra, pregunta, contradicción, hallazgo…), para probar otro arranque sin reescribir.`);
+	const repetidos = reserva.filter((h, i) => arranque(h) === arranque(dicho) || reserva.findIndex((o) => arranque(o) === arranque(h)) !== i);
+	if (dicho && repetidos.length) add('reserva', 'aviso', `${repetidos.length === 1 ? 'Un gancho de reserva arranca' : `${repetidos.length} ganchos de reserva arrancan`} igual que otro ("${arranque(repetidos[0])}…"): son la misma idea con otras palabras. Cambia de arquetipo.`);
+
 	// 2) ritmo y duración (con los tiempos reales si ya hay voz)
 	const es = d?.escenas?.filter((e) => e.tipo !== 'cta') ?? [];
 	if (es.length) {

package/lib/guion.mjs

@@ -364,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. 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.`}],
+			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, cada una de un arquetipo distinto al del gancho y entre sí (cifra imposible, pregunta directa, contradicción, hallazgo, experimento, error común), para probar otra versión.`}],
 			output_config: {format: zodOutputFormat(motor ? await esquemaMotor() : await esquema())},
 		});
 	} catch (e) {

package/lib/skills.mjs

@@ -0,0 +1,40 @@
+// Skills de Morfeo: guías para la IA (guion, animación, 3D) que viajan en el paquete, en `skills/`.
+// `instalarSkills` las copia a `.claude/skills/` del proyecto para que Claude Code las detecte solas; otras IA las
+// leen desde `node_modules/morfeo/skills/` (así lo indica AGENTS.md).
+import fs from 'node:fs';
+import path from 'node:path';
+import {PAQUETE} from './entorno.mjs';
+
+export const CARPETA_SKILLS = path.join(PAQUETE, 'skills');
+
+/** Las skills incluidas: [{nombre, descripcion, carpeta}]. */
+export function listaSkills() {
+	if (!fs.existsSync(CARPETA_SKILLS)) return [];
+	return fs
+		.readdirSync(CARPETA_SKILLS, {withFileTypes: true})
+		.filter((d) => d.isDirectory() && fs.existsSync(path.join(CARPETA_SKILLS, d.name, 'SKILL.md')))
+		.map((d) => {
+			const texto = fs.readFileSync(path.join(CARPETA_SKILLS, d.name, 'SKILL.md'), 'utf8');
+			return {nombre: d.name, descripcion: /^description:\s*(.+)$/m.exec(texto)?.[1]?.trim() ?? '', carpeta: path.join(CARPETA_SKILLS, d.name)};
+		});
+}
+
+/**
+ * Copia las skills de Morfeo a `<proyecto>/.claude/skills/`. Reemplaza solo las carpetas con el nombre de una skill
+ * de Morfeo; cualquier otra skill del proyecto se queda como está.
+ * @returns {string[]} nombres instalados
+ */
+export function instalarSkills(proyecto) {
+	const destino = path.join(proyecto, '.claude', 'skills');
+	fs.mkdirSync(destino, {recursive: true});
+	const hechas = [];
+	for (const s of listaSkills()) {
+		const a = path.join(destino, s.nombre);
+		// un enlace (el repo de Morfeo enlaza las suyas) ya apunta a la fuente: no se toca
+		if (fs.existsSync(a) && fs.lstatSync(a).isSymbolicLink()) continue;
+		fs.rmSync(a, {recursive: true, force: true});
+		fs.cpSync(s.carpeta, a, {recursive: true});
+		hechas.push(s.nombre);
+	}
+	return hechas;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "morfeo",
-	"version": "0.6.7",
+	"version": "0.7.0",
 	"description": "Genera videos verticales animados (Remotion + Three.js) con voz, música y subtítulos, desde un guion en código o escrito por IA.",
 	"type": "module",
 	"license": "SEE LICENSE IN LICENSE",
@@ -45,6 +45,7 @@
 		"python/requirements.txt",
 		"assets",
 		"plantilla",
+		"skills",
 		"bases",
 		"index.d.ts",
 		"LICENSE",

package/plantilla/AGENTS.md

@@ -6,6 +6,19 @@ técnica. Nunca publiques nada por ella: le entregas los archivos y ella decide
 
 Comandos de referencia: `npx morfeo ayuda`. Tipos de todo lo que existe: `node_modules/morfeo/index.d.ts`.
 
+**Guías de oficio (skills).** Morfeo trae cuatro guías en `node_modules/morfeo/skills/`; ábrelas cuando toque, no
+de memoria:
+
+| Vas a… | Lee `node_modules/morfeo/skills/…` |
+|---|---|
+| Hacer un video de principio a fin | `morfeo-video/SKILL.md` |
+| Escribir o mejorar el gancho, la historia o el cierre | `morfeo-guion/SKILL.md` |
+| Decidir entradas, ritmo, énfasis o cámara | `morfeo-animacion/SKILL.md` |
+| Armar un mundo 3D o modelar una pieza | `morfeo-3d/SKILL.md` |
+
+En Claude Code ya están instaladas en `.claude/skills/` y se cargan solas; tras actualizar Morfeo, `npx morfeo skills`
+las pone al día.
+
 **Antes de cada video lee `gustos.md`**: son las reglas de estilo de este canal y mandan sobre lo de abajo. Cuando
 la persona te corrija algo que deba valer para los siguientes videos, ofrécele agregarlo a `gustos.md`.
 
@@ -31,26 +44,29 @@ la persona te corrija algo que deba valer para los siguientes videos, ofrécele
    `npx morfeo nuevo-video <id> --formula <fórmula>` (bases: serie, mito, escalada, biografia, construiste; o
    `--look 2d` / `--look 3d`). Si no, `npx morfeo guion "tema" --formula <fórmula>` o escribe el guion a mano en
    `guiones/<id>.mjs` (mira los ejemplos de `guiones/`).
-3. **Escribe el guion** siguiendo la fórmula y estas reglas:
+3. **Escribe el guion** siguiendo la fórmula, la guía `morfeo-guion` y estas reglas:
+   - Primero el pago (el dato o giro final) en una frase; luego de 6 a 10 ganchos de arquetipos distintos; elige uno.
    - Gancho en los primeros 2 s, en segunda persona o con una cifra imposible. Nada de "hoy te voy a contar".
    - Una idea por escena (2–5 s de voz). Pregunta antes de revelar. Sube la apuesta hacia el final.
    - `say` es lo que dice la voz (cifras con letra); `show` el subtítulo con cifras.
    - Rótulos cortos en 2–4 escenas (`rotulo`, con `rotuloEstilo` sello/paso/pixel si va), `claves` en cada escena.
    - Cierre que pide algo: `{type: 'cta', pide: 'comenta', palabra: 'X'}` o `pide: 'comparte', a: 'tu amigo que…'`.
-   - `title`, `descripcion`, `tags`, `hooks` (3 ganchos de reserva) y `fuentes` (cada dato con su fuente).
+   - `title`, `descripcion`, `tags`, `hooks` (3 ganchos de reserva, de arquetipos distintos) y `fuentes` (cada dato con su fuente).
 4. **Enséñale el guion** (texto de cada escena, en limpio) y espera su visto bueno o sus cambios.
 5. **Enséñale el gancho:** `npx morfeo previa <id>` renderiza solo los primeros segundos. Si no le convence, cámbialo
    (tiene 3 ganchos de reserva en `hooks`).
-6. **Aprueba tomas y ritmo barato:** `npx morfeo animatica <id>` (todo el video a 1/3 de tamaño + su hoja). Si una
+6. **Mundo y movimiento:** si el video lleva mundo 3D o capas animadas, sigue `morfeo-3d` y `morfeo-animacion`
+   (nada entra solo con `aparecer`, lo que se nombra llega en su palabra, algo cambia cada 2–4 s).
+7. **Aprueba tomas y ritmo barato:** `npx morfeo animatica <id>` (todo el video a 1/3 de tamaño + su hoja). Si una
    toma está mal, arréglala y vuelve a pedir solo esas escenas: `npx morfeo render <id> --escenas 5-6`.
-7. **Renderiza y revisa en un paso:** `npx morfeo render <id> --revisar` (video + hoja + revisión). Tras cambiar varios
+8. **Renderiza y revisa en un paso:** `npx morfeo render <id> --revisar` (video + hoja + revisión). Tras cambiar varios
    guiones, `npx morfeo render --cambiados --revisar` rehace solo los que cambiaron.
-8. **Revisa antes de entregar** (si no usaste `--revisar`):
+9. **Revisa antes de entregar** (si no usaste `--revisar`):
    - `npx morfeo revisar <id>`: estructura, que la voz haya dicho el guion, que nada quede bajo los botones de la app,
      el riesgo de "diapositiva" y, en el MP4, cuadros negros, tapados (cámara pegada a algo), lisos o quietos.
    - `npx morfeo hoja <id> --zona`: mira la hoja de contacto (es una imagen); lo pintado en rojo es lo que tapan las apps.
    - Si algo se ve mal (texto encimado, objeto cortado, cuadro vacío), arréglalo y vuelve a renderizar.
-9. **Entrega:** en `salida/` quedan `<título>.mp4`, `<título>.jpg` (miniatura), `<título> (portada).jpg` y
+10. **Entrega:** en `salida/` quedan `<título>.mp4`, `<título>.jpg` (miniatura), `<título> (portada).jpg` y
    `<título>.txt` (texto del post, etiquetas, fuentes y ganchos de reserva). Dile eso y nada más.
 
 ## Reglas

package/skills/CREDITOS.md

@@ -0,0 +1,13 @@
+# Créditos
+
+Las skills de esta carpeta están escritas para Morfeo. Para ordenar sus ideas se consultaron estas guías públicas
+con licencia MIT; no se copió su texto ni viaja ninguna de ellas dentro del paquete:
+
+- [motion-design-skill](https://github.com/LottieFiles/motion-design-skill) (LottieFiles): tiempos, curvas,
+  escalonado y principios de animación.
+- [content-skills](https://github.com/vyralcontent/content-skills) (Vyral): arquetipos de gancho y estructura por
+  retención.
+- [threejs-skills](https://github.com/cloudai-x/threejs-skills) (CloudAI-X): temario de luz, materiales y
+  rendimiento en three.js.
+
+Son recomendaciones basadas en patrones: mejoran las probabilidades, no garantizan resultados.

package/skills/morfeo-3d/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: morfeo-3d
+description: Armar mundos y piezas 3D que se vean bien en un video vertical de Morfeo, cuidando luz, materiales, color, forma de las piezas, encuadre de cámara y rendimiento. Úsala al escribir `escenas/Mundo*.tsx` con `Lienzo3D`, al modelar un objeto en código con React Three Fiber, al elegir tomas (`Toma3D`), y cuando un mundo "se ve plano", "lavado", "vacío", "la cámara está metida en algo" o `npx morfeo revisar` avise de cuadros tapados o lisos.
+---
+
+# 3D: mundos y piezas
+
+## Reglas duras
+
+- **Un solo `Lienzo3D` por video.** El navegador aguanta pocos contextos WebGL.
+- **Todo depende de `t`.** Nada de `useFrame`, relojes ni `Math.random()`; para variar usa una `semilla`.
+- **Primero el kit, luego modelos, al final código.** `morfeo/kit` trae `Persona3D`, `Ciudad`, `Camino`, `Coche`,
+  `Cuarto3D`, `Terreno`, `Mesa`, `Ambiente`… Un objeto suelto: `{tipo: 'recurso', buscar: '…', estilo: '3d'}` o
+  `npx morfeo recursos buscar "…"`. Modela en código solo lo que no exista.
+
+## Luz
+
+`Lienzo3D` trae tres montajes; elige por el lugar, no por gusto:
+
+| `luz` | Qué da | Para |
+|---|---|---|
+| `'dia'` | Cielo claro, sol con sombra suave; `hora` cambia cielo y sol | Exteriores, maquetas, cortes |
+| `'calida'` | Cuarto oscuro con un foco cálido y su cono | Objetos sobre mesa, dinero, piezas |
+| `'noche'` | Ambiente tenue y azulado; las luces las pone el set | Interiores de noche, pantallas, neón |
+
+- **Tres luces mentales:** clave (la que da forma, de lado y arriba), relleno (suave, del lado contrario, un
+  tercio de la clave) y contra (detrás, despega la figura del fondo). Si el sujeto se funde con el fondo, falta contra.
+- **La luz clave nunca viene de la cámara**: aplana. Muévela con `sol` o `foco` a un lado.
+- **Una sola fuente con sombra.** Las demás, sin sombra.
+- **Luces del set** (lámpara, tele, LED): ponlas como objeto emisivo más una luz puntual débil del mismo color.
+  Anímalas con `t` (parpadeo de tele, cambio de LED) para que el fondo viva.
+- **`niebla: [cerca, lejos]`** da profundidad y esconde el borde del mundo; el color es el de `fondo`.
+- **`post`**: `'cine'` (fondo desenfocado y brillo suave), `'miniatura'` (efecto maqueta), `'suave'`. Con sujeto
+  chico y set simple, `'cine'` da profundidad casi gratis.
+
+## Color y materiales
+
+- **Paleta corta:** un color dominante (60 %), uno secundario (30 %) y un acento (10 %) para lo que hay que mirar.
+  El acento no se repite en el fondo.
+- **`meshStandardMaterial`** para todo. Dos perillas: `roughness` (0.3 pulido … 0.9 mate) y `metalness` (0 o cerca
+  de 0.85; los valores intermedios se ven raros).
+
+| Material | `roughness` | `metalness` |
+|---|---|---|
+| Plástico | 0.4–0.5 | 0.1 |
+| Pintura mate, tela, madera | 0.6–0.9 | 0 |
+| Metal pulido | 0.25–0.35 | 0.85 |
+| Goma | 0.9 | 0 |
+| Vidrio, agua | 0.05–0.15, `transparent`, `opacity` 0.3–0.75 | 0.1–0.3 |
+
+- **Emisivo con medida:** `emissiveIntensity` 0.3–0.8 para luces y pantallas. Si todo brilla, nada brilla, y los
+  colores se lavan.
+- **Colores lavados** casi siempre son demasiada luz ambiente: bájala antes de saturar los colores.
+- **Negro puro y blanco puro no**: usa `#1B1C22` y `#F7F5F0`; conservan volumen.
+- **Contraste con el fondo:** el sujeto debe ser más claro o más saturado que lo que tiene detrás.
+
+## Modelar una pieza en código
+
+- **Silueta primero.** A tamaño de pulgar debe reconocerse por el contorno. Si no, exagera lo que la identifica
+  (el volante de la bici, las capas del cable) y quita detalle.
+- **Formas simples combinadas:** cajas, cilindros, esferas, conos, aros y tubos. De 8 a 30 piezas suele bastar.
+- **Proporciones algo exageradas** (cabezas grandes, grosores generosos): lo delgado desaparece en vertical.
+- **Arma derecho y luego inclina el grupo.** Si inclinas cada parte por separado, quedan despegadas.
+- **Piezas planas** (pantallas, tarjetas): inclina la cara hacia la cámara.
+- **Corte para ver por dentro:** quita la pared de enfrente en vez de hacerla transparente; se lee mejor.
+- **Un detalle que se mueva** (gira, parpadea, gotea, respira) con `t`.
+- **Tamaño:** que quepa en ±1.2 unidades, centrada en el origen, para que se pueda escalar y colocar.
+- **Segmentos:** 24–36 en cilindros protagonistas, 12 en los chicos. Más no se nota.
+
+## Componer el mundo
+
+- **Vertical = profundidad, no anchura.** Acomoda las cosas una detrás de otra, no lado a lado.
+- **Tres planos:** algo cerca (aunque sea desenfocado), el sujeto en medio y fondo con vida.
+- **Viste el set:** un cuarto vacío con un objeto se ve pobre. Suelo, pared o cielo, dos o tres cosas de utilería
+  y una luz propia. `Ambiente` (`cuarto-gamer`, `sala`, `arcade`…) ya lo trae hecho.
+- **Suelo siempre.** Los objetos flotando sin sombra no pesan.
+- **Lo que aún no se nombra, no está**: que llegue con `Aparece` en su palabra (`en={cuando('motor')}`).
+
+## Cámara (fov 38, cuadro 1080×1920)
+
+A distancia `d` se ven ±0.19·d de ancho y ±0.34·d de alto. Para que algo de ancho `W` llene ~70 % del cuadro,
+`d ≈ 3.7·W`.
+
+| Toma | Para | Cómo |
+|---|---|---|
+| General | Decir dónde estamos | En diagonal y desde arriba; nunca de frente |
+| Media | El sujeto y lo que hace | A la altura de los ojos, un poco de lado |
+| Detalle | Lo que se nombra | `fov` 28–32, cerca, fondo simple |
+| Cenital | Mapas, mesas, recorridos | Desde arriba, con una ligera inclinación |
+| Contrapicado | Que algo imponga | Cámara baja mirando hacia arriba |
+
+- **Una toma por escena** en `TOMAS`; `a` la mueve, `corte: true` salta, `deriva` acerca despacio.
+- **Mira al objeto por su cara buena**: comprueba que no lo ves por detrás.
+- **Nada entre la cámara y el sujeto.** `despejado` hace que la cámara avance si algo le tapa el lente.
+- **No pegues la cámara**: si un solo color llena el cuadro, estás dentro de algo o demasiado cerca.
+- **Etiquetas 3D** cerca de la orilla se cortan: `lado: 'izq'` o `'der'` hacia el centro.
+- **Aprueba las tomas barato:** `npx morfeo animatica <id>` y, para corregir una, `npx morfeo render <id> --escenas 5`.
+
+## Rendimiento
+
+- Repetidos (multitudes, árboles, ladrillos): `instancedMesh` o las piezas del kit que ya lo usan (`Multitud3D`).
+- Geometría calculada (`TubeGeometry`, `ExtrudeGeometry`): dentro de `useMemo`, no en cada cuadro.
+- Transparencias, pocas: cada una cuesta y se ordenan mal entre sí.
+- Sombras: una luz. Modelos `.glb`: menos de unos miles de triángulos por objeto.
+- Si el render va lento, baja primero el número de mallas, no la calidad.
+
+## Lista antes de entregar
+
+- [ ] El sujeto se despega del fondo (contra, contraste o niebla).
+- [ ] Hay suelo y sombra; nada flota sin querer.
+- [ ] Paleta de tres colores; el acento solo en lo importante.
+- [ ] Cada toma muestra el objeto entero y por su cara buena.
+- [ ] El fondo tiene algo que se mueve.
+- [ ] En la hoja (`npx morfeo hoja <id>`) ningún cuadro está tapado, liso ni vacío.

package/skills/morfeo-animacion/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: morfeo-animacion
+description: Decidir cómo se mueve cada cosa en un video de Morfeo, es decir entradas y salidas de capas, tiempos y curvas, escalonado, énfasis, movimiento de ambiente y cámara (2D y 3D). Úsala al poner `entrada`, `en`, `curva`, `toma`, `transicion` o `Aparece`, al animar una pieza o un mundo en código, y cuando el video "se ve como diapositiva", "todo entra igual", "se siente tieso" o `npx morfeo revisar` avise de cuadros quietos.
+---
+
+# Animación: cómo se mueve cada cosa
+
+## Regla dura
+
+Todo movimiento sale del cuadro actual. En los componentes usa el `t` (segundos) que te da Morfeo, `tEscena`,
+`cuando('palabra')` o `useCurrentFrame()`. **Nunca** `useFrame`, transiciones o animaciones CSS, `Date`,
+`setTimeout`, `Math.random()` sin semilla ni mezcladores con reloj propio: el render saca cuadros sueltos y en
+desorden, y cualquier cosa que dependa del reloj real sale distinta en cada cuadro. Para azar usa `ruido(t, semilla)`.
+
+## Antes de animar: tres preguntas
+
+1. **¿Qué debe sentir quien lo ve?** Sorpresa, calma, urgencia, gracia. De eso salen curva y duración.
+2. **¿Quién es el protagonista de este momento?** Uno solo. Lo demás acompaña o se queda quieto.
+3. **¿Están las tres capas de movimiento?** Principal (lo que se sigue con la vista), secundaria (lo que reacciona:
+   una sombra, una etiqueta que llega después) y de ambiente (fondo vivo). Si falta una, se ve plano.
+
+## Entradas de capa
+
+| `entrada` | Se siente | Úsala para |
+|---|---|---|
+| `escala` (por defecto) | Neutra | Casi todo |
+| `rebote` | Juguetona, con sobrepaso | Objetos, premios, lo que "cae bien" |
+| `caer` | Pesada | Sellos, cosas que golpean |
+| `subir` | Tranquila | Fuentes, secciones, textos largos |
+| `deslizar-izq` / `-der` / `-arriba` / `-abajo` | Con dirección | Lo que viene de algún lado o continúa un movimiento |
+| `girar` | Llamativa | Una vez por video, no más |
+| `enfocar` | De cine | Revelar algo importante |
+| `aparecer` | Discreta | Solo apoyo; nunca para lo importante (ver reglas) |
+| `ninguna` | Corte seco | Cambios a ritmo de la voz, listas rápidas |
+
+`curva`: `'suave'` (frena al llegar; por defecto), `'resorte'` (sobrepasa y asienta; juguetón) o `'seca'` (rápida y
+decidida; énfasis). El estilo fija una para todo el video en `movimiento`; cámbiala por capa solo con motivo.
+
+## Tiempos
+
+| Qué | Duración | En Morfeo |
+|---|---|---|
+| Golpe, sello, cifra que cae | 0.15–0.25 s | `duracionEntrada: 0.2`, `curva: 'seca'` |
+| Icono, etiqueta, chip | 0.25–0.35 s | `duracionEntrada: 0.3` |
+| Tarjeta, objeto, personaje | 0.4–0.55 s | El valor por defecto (0.5) |
+| Revelación con peso | 0.6–1.2 s | `enfocar` o `escalar` lento |
+| Movimiento de ambiente | 2–20 s por ciclo | `flotar`, `girar`, deriva de cámara |
+
+- **Entrar tarda más que salir**: la salida dura entre 65 y 75 % de la entrada.
+- **Más distancia, más tiempo**: lo que cruza media pantalla tarda ~1.5× lo que se mueve un poco.
+- **Peso**: lo grande y pesado va más lento y sin sobrepaso; lo chico y ligero, rápido y con rebote.
+- **Sobrepaso**: 0 % en errores y cosas serias, 5–10 % en aciertos, 15–25 % en festejos.
+
+Curvas, resortes y equivalencias: [referencias/tiempos.md](referencias/tiempos.md).
+
+## Coreografía
+
+- **Primero el protagonista**; lo demás entra después y desde el mismo lado.
+- **Escalona**: entre capas hermanas deja 0.05–0.1 s (`en: 'palabra'`, `'palabra+0.08'`, `'palabra+0.16'`). El
+  escalonado completo no pasa de 0.5 s; si hay muchas, baja el paso a 0.03 s.
+- **Regla del tercio (cantidad):** con tres o más cosas en pantalla, se mueve a la vez como mucho una tercera parte.
+- **Regla del tercio (distancia):** nada recorre más de un tercio del cuadro sin un cambio (pausa, giro, otra curva).
+- **Lo secundario llega 0.05–0.15 s tarde**: la etiqueta después del objeto, el número después de la barra.
+- **Contramovimiento**: si el protagonista va a la derecha, el fondo deriva un poco a la izquierda.
+- **Sincroniza con la voz**: lo que se nombra aparece en la palabra (`en: 'palabra'`), no antes ni después. Para
+  golpes, `'palabra-0.05'` se siente más justo que tarde.
+
+## Principios que más se notan
+
+- **Anticipación:** antes de un movimiento grande, uno chico en sentido contrario (encoger 3–5 % y luego crecer;
+  retroceder antes de saltar). En código: `escala = 1 - 0.04 * campana(k)` justo antes de `en`.
+- **Aplastar y estirar:** al caer algo, aplástalo 8–12 % un instante y recupéralo (así lo hace `Aparece`).
+- **Arcos:** las cosas vivas se mueven en curva, no en línea recta; añade un desvío lateral a medio camino.
+- **Seguir y asentar:** tras llegar, sobrepasa un poco y regresa (`'resorte'`, `backOut`).
+- **Nada perfectamente quieto:** lo que queda en pantalla más de 2 s respira (`flotar`, `latir`, giro lento,
+  parpadeo). La cámara también: deriva lenta si no hay otro movimiento.
+- **Una sola cosa llamativa por momento.** Si todo rebota, nada destaca.
+
+## Énfasis
+
+- Rótulos `sello` y `pixel` ya traen golpe de cámara (`golpe: false` lo quita). No sumes otro efecto encima.
+- Cifras: `contador` o `dato` que cuenta hasta el valor; el número pesa más si llega 0.1 s después de su objeto.
+- `latir` para lo que hay que mirar; `escalar: {a: 1.15, en: 'palabra'}` para subrayar una palabra.
+- El sonido sale solo según la entrada; `sonido: false` cuando varias capas entran juntas (un solo golpe basta).
+
+## Cámara
+
+**2D (`toma` por escena):** `{x, y, zoom}` centra un punto del mundo; `a: {...}` la mueve durante la escena;
+`deriva` la acerca despacio; `corte: true` salta sin viaje.
+
+**3D (`Toma3D` por escena):** `{pos, mirar, fov}`; `a` para moverla, `viaje` para la duración del traslado,
+`corte: true` para saltar, `deriva` para el acercamiento lento.
+
+- **Cambia algo cada 2–4 s**: corte, viaje o entrada. Con `ambiente`, `cortes` reparte sub-tomas dentro de la escena.
+- **Corta** cuando cambia el tema o el lugar; **viaja** cuando sigues la misma cosa.
+- **Secuencia que funciona:** general (dónde estamos) → detalle (lo que se nombra) → reacción (el personaje).
+- No encadenes dos viajes largos seguidos: marea. Viaje, corte, viaje.
+- Acercar sube la tensión; alejar la suelta o revela escala.
+- `transicion` entre escenas: `corte` por defecto; `barrido` o `empuje` cuando se cambia de lugar; `fundido` para
+  pasos de tiempo; `destello` y `zoom` contados (una o dos veces por video).
+
+## Animar en código (mundos y piezas)
+
+Del kit (`morfeo/kit`): `clamp`, `lerp`, `easeOut`, `easeIO`, `easeOutExpo`, `backOut`, `resorte`, `ruido`.
+
+```tsx
+const k = clamp((t - cuando('motor')) / 0.5);      // avance 0..1 desde la palabra
+const y = lerp(4, 0, easeOut(k));                    // llega frenando
+const s = backOut(k);                                // crece con sobrepaso
+const respira = 1 + Math.sin(t * 1.6) * 0.02;        // ambiente
+```
+
+- Movimiento en el espacio: nunca lineal (solo giros continuos y barras de progreso).
+- Ciclos de ambiente con senos de periodos distintos (1.6, 2.3, 3.1) para que no se note la repetición.
+- `Aparece` (`desde: 'arriba' | 'crece' | 'izq' | 'der' | 'abajo'`) ya resuelve caída, rebote y aplastamiento.
+- Varias partes: mismo patrón con `en` escalonado (`en + i * 0.08`).
+
+## Lista antes de entregar
+
+- [ ] Cada escena tiene principal, secundaria y ambiente.
+- [ ] Ninguna entrada importante es solo `aparecer`.
+- [ ] Las hermanas entran escalonadas y el total no pasa de 0.5 s.
+- [ ] Nada cruza más de un tercio del cuadro de un tirón.
+- [ ] Lo que se nombra aparece en su palabra (sin avisos `!` en el render).
+- [ ] No hay más de 3 s sin cambio visible (`npx morfeo revisar` lo marca como cuadro quieto).
+- [ ] Hay como mucho un efecto llamativo por momento.
+- [ ] Se entiende a velocidad normal, sin pausar.

package/skills/morfeo-animacion/referencias/tiempos.md

@@ -0,0 +1,94 @@
+# Tiempos, curvas y resortes
+
+Morfeo trabaja a 30 cuadros por segundo: 0.1 s = 3 cuadros. Menos de 3 cuadros no se percibe como movimiento.
+
+## Curvas del kit y cuándo usarlas
+
+| Función (`morfeo/kit`) | Forma | Para |
+|---|---|---|
+| `easeOut(k)` | Arranca rápido, frena al llegar | Entradas (lo normal) |
+| `easeOutExpo(k)` | Frena mucho más brusco | Golpes, énfasis, lo "seco" |
+| `easeIO(k)` | Suave en los dos extremos | Lo que se mueve estando ya en pantalla; cámara |
+| `backOut(k, s)` | Sobrepasa y regresa (`s` = cuánto) | Objetos juguetones, aciertos |
+| `resorte(k, rebote)` | Oscila y asienta | Festejos, cosas elásticas |
+| `Math.sin(t * w)` | Va y viene sin fin | Ambiente, respiración, flotar |
+| lineal (`k`) | Constante | Solo giros continuos y barras de progreso |
+
+Dirección: **entrar frena** (`easeOut`), **salir acelera** (`k * k`), **moverse en pantalla** usa `easeIO`.
+
+En capas, `curva: 'suave'` = `easeOut`, `'seca'` = `easeOutExpo`, `'resorte'` = `resorte(k, 0.3)`; `entrada: 'rebote'`
+usa `backOut`.
+
+## Duración según lo que es
+
+| Elemento | Segundos | Cuadros |
+|---|---|---|
+| Micro-reacción (parpadeo, pulso) | 0.08–0.12 | 3–4 |
+| Golpe, sello | 0.15–0.25 | 5–8 |
+| Icono, chip, etiqueta | 0.25–0.35 | 8–10 |
+| Objeto, tarjeta, personaje | 0.4–0.55 | 12–16 |
+| Cambio de escena (`transicion`) | 0.35–0.5 | 10–15 |
+| Revelación con peso | 0.6–1.2 | 18–36 |
+| Viaje de cámara | 0.8–1.6 | 24–48 |
+| Ciclo de ambiente | 2–20 | — |
+
+Distancia: poca = ×0.8, media = ×1, media pantalla = ×1.5, pantalla completa = ×1.8–2.
+Salida = 65–75 % de la entrada.
+
+## Carácter del video
+
+Elige uno para todo el video y fíjalo en `movimiento` del estilo; no lo mezcles escena a escena.
+
+| Carácter | Rápida / normal / lenta (s) | Curva | Sobrepaso | Va con |
+|---|---|---|---|---|
+| Juguetón | 0.15 / 0.25 / 0.4 | `resorte` | 10–20 % | Curiosidades, humor, niños |
+| Enérgico | 0.1 / 0.18 / 0.3 | `seca` | 15–30 % en festejos | Retos, escaladas, conteos |
+| Sobrio | 0.2 / 0.3 / 0.45 | `suave` | 0–3 % | Tutoriales, explicadores, noticias |
+| Elegante | 0.35 / 0.5 / 0.8 | `suave` | 0 % | Biografías, historias serias |
+
+## Emoción → movimiento
+
+| Emoción | Trayectoria | Curva | Duración |
+|---|---|---|---|
+| Alegría | Arcos hacia arriba | `backOut` | 0.2–0.4 |
+| Calma | Curvas suaves | seno | 0.5–1.0 |
+| Urgencia | Rectas, cortas | `easeOutExpo` | 0.1–0.2 |
+| Tristeza | Hacia abajo, lenta | `easeIO` | 0.6–1.2 |
+| Sorpresa | Del centro hacia fuera | `easeOutExpo` | 0.15–0.3 |
+| Misterio | Deriva lenta, aparece de lo oscuro | `easeIO` + `enfocar` | 0.8–1.5 |
+
+Trayectorias: angular = tensión; curva = amable; diagonal = intención; vertical = peso o crecimiento;
+horizontal = avance.
+
+## Material → cómo se mueve
+
+| Material | Duración | Sobrepaso |
+|---|---|---|
+| Rígido (metal, piedra) | ×1.2 | 0 % |
+| Elástico (goma, gel) | ×0.8 | 15–25 % |
+| Líquido | ×1.5 | 5 % |
+| Papel, cartón | ×1 | 3–5 % |
+| Humo, niebla | ×2 | 0 % |
+
+## Escalonado
+
+| Patrón | Paso entre elementos | Total máximo | Para |
+|---|---|---|---|
+| Cascada fina | 0.02–0.04 s | 0.2 s | Listas, rejillas, barras |
+| Normal | 0.05–0.1 s | 0.4 s | Tarjetas, objetos |
+| Dramático | 0.1–0.2 s | 0.6 s | Tres piezas protagonistas |
+
+Orden: de arriba abajo en listas, de izquierda a derecha en filas, del centro hacia fuera en un protagonista,
+inverso en las salidas.
+
+## Fórmulas útiles (todo depende de `t`)
+
+```tsx
+const k = clamp((t - en) / dur);                         // avance 0..1
+const campana = Math.sin(clamp(k) * Math.PI);            // sube y baja: anticipación, aplastamiento
+const anticipa = 1 - 0.04 * Math.sin(clamp((t - (en - 0.12)) / 0.12) * Math.PI);   // encoge antes de salir
+const arco = lerp(x0, x1, easeOut(k)); const alto = campana * 0.4;                 // trayectoria en arco
+const sacude = k < 1 ? Math.sin(k * Math.PI * 6) * (1 - k) * 12 : 0;               // 3 oscilaciones que se apagan
+const flota = Math.sin(t * 1.6 + semilla) * 0.05;        // ambiente; cambia la semilla por objeto
+const parpadea = 0.5 + 0.5 * Math.max(0, Math.sin(t * 4 + i));                    // luces
+```

package/skills/morfeo-guion/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: morfeo-guion
+description: Escribir o mejorar el guion de un video corto vertical de Morfeo, con ganchos (generar varios y elegir), orden de la historia por retención, escalada, pago y cierre. Úsala al escribir `guiones/<id>.mjs`, cuando pidan "mejora el gancho", "el video aburre", "dame ganchos para…", "reescribe el guion", o cuando `npx morfeo revisar` avise de gancho, ritmo, preguntas o cierre.
+---
+
+# Guion: gancho, historia y cierre
+
+Un video corto se decide en los primeros 2 segundos y se sostiene con una pregunta abierta hasta el final. Estas
+reglas suben las probabilidades; no prometen que un video se vuelva viral, y no lo prometas tú.
+
+## Orden de trabajo
+
+1. **Escribe primero el pago**: el dato, giro o imagen por el que valió la pena ver el video, en una frase. Si no
+   cabe en una frase, el tema todavía no está claro.
+2. **Escribe de 6 a 10 ganchos** de al menos tres arquetipos distintos (tabla de abajo). Uno solo es una apuesta.
+3. **Elige uno** con la lista de comprobación y guarda **tres de reserva, de arquetipos distintos**, en `hooks`.
+4. **Arma hacia atrás** desde el pago: qué necesita saber el espectador, en qué orden, y qué pregunta lo mantiene.
+5. **Cierra** pidiendo una sola cosa concreta.
+6. Revisa con `npx morfeo revisar <id>` y con los fallos comunes de abajo.
+
+## El gancho tiene tres capas
+
+En los primeros 2 segundos trabajan juntas. Una buena frase sobre un cuadro vacío es medio gancho.
+
+| Capa | Qué es en Morfeo | Regla |
+|---|---|---|
+| Imagen | Lo que hay en el cuadro 1: el sujeto ya en pantalla y algo moviéndose | Debe entenderse sin sonido |
+| Voz | El `say` de la primera escena | Se dice en menos de 2 s; sin saludo ni presentación |
+| Texto | `rotulo` de la primera escena (o el subtítulo) | 3 a 7 palabras, con la cifra o la palabra fuerte |
+
+Las tres dicen lo mismo y coinciden con el `title`. Si el título promete algo, el primer cuadro ya lo muestra.
+
+## Arquetipos de gancho
+
+| Arquetipo | Molde | Cuándo |
+|---|---|---|
+| Cifra imposible | "Este cartucho sabe a lo más amargo del mundo: [cifra]." | Hay un número raro y verificable |
+| Pregunta directa | "¿Y si tu [cosa] llevara [tiempo] haciendo [algo]?" | El tema toca la vida del espectador |
+| Contradicción | "Todos creen que [X]. No es así." | Tienes cómo sostenerlo; el pago debe defenderlo |
+| Hallazgo | "Hay [algo oculto] dentro de [cosa conocida]." | Explicadores y "por dentro" |
+| Experimento | "Jugué [X] durante [tiempo] para saber [Y]." | Hay una prueba con resultado |
+| Esto es X, pero… | "Este es [nombre]. Hoy va a [giro]." | Historias con personaje |
+| Mira esto | "Fíjate en [detalle]. No debería estar ahí." | La imagen sola ya sorprende |
+| Error común | "Llevas años [haciendo X] mal." | Tutoriales y consejos |
+
+La contradicción es la que más sube cuando funciona y la que más falla; el hallazgo es más parejo. Un buen lote
+lleva de las dos. Más moldes y ejemplos: [referencias/ganchos.md](referencias/ganchos.md).
+
+**Comprobación de un gancho** (todas deben cumplirse):
+
+- Tiene un sustantivo concreto o una cifra, no una promesa vaga ("no vas a creer…").
+- Se entiende con el sonido apagado.
+- Termina antes del segundo 2 y deja una pregunta abierta.
+- Lo que promete, el video lo cumple. Si exagera, se quita.
+- No empieza con saludo, nombre del canal, "hoy te voy a contar" ni una orden ("mira esto hasta el final").
+
+## La historia: una pregunta abierta todo el tiempo
+
+| Tramo | Segundos (video de 30–45 s) | Qué hace |
+|---|---|---|
+| Gancho | 0–2 | Abre la pregunta grande |
+| Contexto mínimo | 2–6 | Solo lo necesario para entender la pregunta; una o dos escenas |
+| Escalada | 6–30 | Cada escena responde una pregunta chica y abre otra; cada una más grande o más rara que la anterior |
+| Pago | últimos 5–8 | Responde la pregunta grande con el dato o giro más fuerte |
+| Cierre | 2–4 | Pide una cosa |
+
+- **Una idea por escena, de 2 a 5 s de voz.** Si una escena no agrega nada nuevo, se borra.
+- **Pregunta antes de revelar.** La pregunta en una escena, la respuesta en la siguiente con cifra o golpe visual.
+- **Un giro hacia la mitad** ("pero ahí no acaba", un dato que contradice lo anterior): sin él, la gente se va de a poco.
+- **Lo más fuerte cerca del final**, no al principio. El gancho promete; el pago entrega.
+- **No adelantes el pago** en el contexto, y no lo entierres: si tarda más de 40 s, acorta la escalada.
+- **Bucle:** la última frase puede regresar a la primera imagen o dejar una pregunta que haga volver a verlo.
+
+La fórmula del video (`npx morfeo formulas`) fija los tramos propios de cada formato (mito, misterio, biografía,
+experimento…); estas reglas se aplican dentro de ella. Detalle por tramo y cómo leer una caída de retención:
+[referencias/estructura.md](referencias/estructura.md).
+
+## Voz
+
+- Segunda persona y presente: "te despiertas", "abres la caja". En historias, nombre propio en la primera frase.
+- Frases cortas, una idea cada una. Lee el guion en voz alta: si te quedas sin aire, córtala.
+- `say` lleva las cifras en letra; `show` las lleva en número. Cifras raras y exactas pesan más que las redondas,
+  pero solo si tienen fuente (`fuentes`). Si dudas de una cifra, dila en general o quítala.
+- Sin relleno: "básicamente", "como ya sabes", "en este video".
+
+## Cierre
+
+Pide **una** cosa, fácil y concreta, ligada al contenido:
+
+- Elegir: `{type: 'cta', pide: 'comenta', palabra: 'X'}` con una pregunta de A o B.
+- Compartir: `pide: 'comparte', a: 'tu amigo que dice que…'`.
+- Parte 2 si es serie (`serie`).
+
+"Sígueme" solo no basta, y no se pide nada antes de haber entregado el pago.
+
+## Fallos comunes
+
+| Fallo | Cómo se nota | Arreglo |
+|---|---|---|
+| Presentación antes del gancho | Primera escena saluda o explica de qué va | Borra esa escena; empieza en la acción |
+| Gancho vago | "Esto te va a sorprender" | Pon el sustantivo o la cifra |
+| Gancho que no se cumple | El pago es más chico que la promesa | Baja la promesa o sube el pago |
+| Mitad plana | Tres escenas seguidas del mismo tamaño | Añade un giro o quita dos |
+| Pago adelantado | El dato fuerte sale en el contexto | Muévelo al final; deja la pregunta |
+| Dos ideas en una escena | Escena de más de 5 s sin nada nuevo en pantalla | Pártela |
+| Cierre genérico | "Sígueme para más" | Pregunta de A o B o "mándaselo a…" |
+
+## Entrega
+
+`title`, `descripcion`, `tags`, `hooks` (3 de reserva) y `fuentes`. Enseña el guion en limpio y espera el visto
+bueno antes de renderizar; `npx morfeo previa <id>` muestra solo el gancho para probar variantes baratas.

package/skills/morfeo-guion/referencias/estructura.md

@@ -0,0 +1,61 @@
+# Estructura por retención
+
+La retención son dos cosas: quedarse o deslizar en los primeros 3 segundos, y cuánta gente sigue en cada segundo
+después. Un guion se arma para que la curva caiga lo menos posible.
+
+## Tres formas de perder gente y qué cambiar en el guion
+
+| Forma de la caída | Causa en el guion | Arreglo |
+|---|---|---|
+| Barranco en los primeros 3 s | Cuadro inicial flojo, primera frase lenta, saludo, o el gancho no coincide con el título | Reescribe entero el arranque; prueba otro arquetipo de `hooks` |
+| Goteo constante en la mitad | No hay escalada ni giro: todas las escenas pesan igual | Mete un giro entre el segundo 5 y el 8 y otro hacia la mitad; quita escenas planas |
+| Barranco antes del final | El pago tarda o no llega; la gente se rindió | Adelanta el pago o recorta la preparación |
+
+Meta: una línea casi plana y un pequeño repunte al final por las repeticiones.
+
+## Duración
+
+- De 30 a 45 s es el punto dulce: alcanza para contar algo y se sostiene la atención.
+- Menos de 15 s rara vez junta tiempo de visualización suficiente aunque se vea completo.
+- Más de 60 s exige más giros: uno cada 8–10 s. Las maquetas (90–130 s) viven de cortes de cámara cada 2–3 s.
+
+## Tramo por tramo
+
+**Gancho (0–2 s).** Una escena. Sujeto en pantalla, frase de menos de 2 s, rótulo de 3 a 7 palabras.
+
+**Contexto (2–6 s).** Lo mínimo para que la pregunta se entienda: quién, qué, cuándo. Si puedes borrarlo y el
+video se entiende igual, bórralo.
+
+**Escalada.** Cadena de mini-preguntas: cada escena cierra una y abre la siguiente.
+
+```
+escena 3: "¿Y por qué sabe así?"            → abre
+escena 4: "Porque lo pintan con esto."       → cierra y abre: ¿qué es "esto"?
+escena 5: "Es la sustancia más amarga…"      → cierra y sube: ¿qué tan amarga?
+escena 6: "[la cifra con fuente]"            → giro: cifra que no esperabas
+```
+
+Cada escena debe ser más grande, más rara o más cercana al espectador que la anterior. Si dos escenas se pueden
+intercambiar sin que se note, no hay escalada.
+
+**Giro.** Algo que contradice lo que el espectador ya daba por hecho: "pero no era para eso", "y aun así la gente
+los lame". Uno hacia la mitad; en videos largos, uno cada 8–10 s.
+
+**Pago.** La respuesta a la pregunta del gancho, con el dato más fuerte, dicho claro y mostrado en pantalla
+(`dato`, `contador`, rótulo `sello`). Sin "y bueno, pues eso".
+
+**Cierre.** Una petición. Si puedes, que la última frase haga que la primera suene distinta.
+
+## Bucles (repeticiones gratis)
+
+- **Visual:** el último cuadro se parece al primero (mismo objeto, mismo encuadre).
+- **De voz:** la última frase entrega bien a la primera, sin "gracias por ver".
+- **De pregunta:** el cierre hace releer el arranque.
+- **De corte:** terminar en "la verdadera razón es…" y que la respuesta sea el arranque.
+
+## Prueba rápida antes de renderizar
+
+1. Tapa la primera escena: ¿el video sigue enganchando? Entonces el gancho estaba en la escena 2; súbelo.
+2. Lee solo los rótulos en orden: ¿cuentan la historia?
+3. Marca en qué escena se responde la pregunta del gancho. Si es antes del último tercio, muévela.
+4. Cuenta las escenas sin dato, giro ni imagen nueva. Deben ser cero.

package/skills/morfeo-guion/referencias/ganchos.md

@@ -0,0 +1,57 @@
+# Ganchos: moldes, tácticas y errores
+
+## Lote de ejemplo
+
+Tema: "los cartuchos de una consola llevan una sustancia amarga para que los niños no se los traguen".
+
+| Arquetipo | Voz (`say`) | Imagen del cuadro 1 | Texto (`rotulo`) |
+|---|---|---|---|
+| Cifra imposible | "Este cartucho lleva la sustancia más amarga que existe." | El cartucho grande, girando, con una gota encima | LO MÁS *AMARGO* |
+| Pregunta directa | "¿Alguna vez lamiste un cartucho? No lo hagas." | Una lengua acercándose al cartucho | ¿LO *LAMISTE*? |
+| Hallazgo | "Hay algo escondido en la pintura de este cartucho." | Lupa sobre la superficie | ESTÁ EN LA *PINTURA* |
+| Contradicción | "No sabe mal por accidente. Lo hicieron a propósito." | Cartucho con sello de "aprobado" | FUE *A PROPÓSITO* |
+| Experimento | "Probé un cartucho para que tú no tengas que hacerlo." | Persona con cara de asco | NO LO *PRUEBES* |
+
+Se elige uno y tres pasan a `hooks`. Los cinco prometen lo mismo que el video entrega.
+
+## Más moldes
+
+- **"Cómo [resultado] sin [molestia]."** Dice el valor en una línea. Tutoriales.
+- **"[N] cosas que ojalá hubiera sabido antes de [Y]."** Listas; N impar o raro.
+- **"El [enemigo conocido] es [malo]. El [héroe] es [bueno]. ¿Y si…?"** Tres golpes cortos.
+- **Predicción:** "Esto va a cambiar cómo [público] [hace algo]." Solo con una demostración que lo respalde.
+- **Reserva:** "Encontré lo único que volvería a comprar. No te digo cuál todavía." Sirve si el nombre llega pronto.
+
+## De una idea, trece ganchos
+
+Si te atoras, cambia de ángulo sobre la misma afirmación: consejo, estadística, pasos, historia, cita, beneficio,
+lección, razón, error, ejemplo, pregunta, recurso, marco. Cada ángulo da un gancho distinto.
+
+## Tácticas chicas que suben la retención del arranque
+
+- **Número raro y exacto** ("37 horas", no "muchas horas"). Suena medido. Solo si es cierto.
+- **Verbo fuerte** en la primera palabra o la segunda: "rompí", "encontré", "cuesta".
+- **Dolor o deseo del espectador** nombrado: que se reconozca en el primer segundo.
+- **Señal de autoridad** breve si la hay ("llevo ocho años reparando controles").
+- **Corte de patrón visual:** el primer cuadro no se parece al video anterior del canal (otro ángulo, otro color).
+- **La forma de la curiosidad:** di lo suficiente para que importe y calla justo lo que el video responde.
+
+## Errores que tumban los primeros 2 segundos
+
+| Error | Por qué falla |
+|---|---|
+| Saludo, logo, cortinilla, "bienvenidos" | Gasta el tiempo en que se decide si se queda |
+| Promesa vaga ("no vas a creer lo que pasó") | No hay nada concreto que querer saber |
+| Exagerar lo que el video entrega | Gana el clic y pierde la satisfacción; el espectador se siente engañado |
+| Pedir seguir antes de dar valor | Nadie sigue a quien todavía no le dio nada |
+| Abrir contando una historia larga | La historia va después del gancho, no en su lugar |
+| Dar órdenes ("quédate hasta el final") | Se siente a truco; mejor una razón |
+| Solo la frase, sin imagen ni texto | Con el sonido apagado no hay gancho |
+| Marca primero | El espectador no vino por la marca |
+| Ingenio que hay que explicar | Si necesita un segundo de pensar, ya deslizó |
+| Gancho de 10 segundos | Planteamiento, nudo y desenlace dentro del gancho: demasiado largo |
+
+## Cómo criticar un gancho ajeno
+
+Di **qué capa** está floja (imagen, voz o texto) y **qué error** de la tabla comete; luego reescribe tres variantes
+de arquetipos distintos. Señalar sin reescribir no ayuda.

package/skills/morfeo-video/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: morfeo-video
+description: Hacer un video corto vertical con Morfeo de principio a fin a partir de un tema (historia con personajes, curiosidad, "qué pasaría si", tutorial, explicador de maqueta), en 2D o 3D. Úsala cuando pidan "haz un video de…", "otro video sobre…", "una serie de…", o cuando haya que escribir un guion y su mundo en un proyecto de Morfeo (carpeta con morfeo.config.mjs).
+---
+
+# Hacer un video con Morfeo
+
+Tú escribes el guion **y** el mundo a medida, lo renderizas y lo revisas a ojo antes de decir que está listo. Nunca
+copies videos de otros: se toma la forma, no el contenido. Si el proyecto tiene `gustos.md`, léelo primero: manda.
+
+## 0. Dónde y qué más leer
+
+- Proyecto: la carpeta con `morfeo.config.mjs`. Corre los comandos ahí. Tipos de todo: `node_modules/morfeo/index.d.ts`.
+- Esta skill es la ruta completa. Para hacerlo bien, abre la que toque en cada paso:
+
+| Cuando vayas a… | Lee |
+|---|---|
+| Escribir el gancho, ordenar la historia o el cierre | `morfeo-guion` |
+| Decidir entradas, ritmo, énfasis o movimiento de cámara | `morfeo-animacion` |
+| Armar un mundo 3D o una pieza (luz, materiales, encuadre) | `morfeo-3d` |
+
+Están junto a esta, en `node_modules/morfeo/skills/` (y en `.claude/skills/` si corriste `npx morfeo skills`).
+
+## 1. Decide el look (2D o 3D) — cualquier tema va en cualquiera
+
+| Si el tema es… | Look que mejor funciona | Base |
+|---|---|---|
+| Historia con personas, emociones, diálogo | 2D: `Persona2D` + escenario (`CiudadNoche`, `Cuarto`, `Calle`, `Campo`, `Oficina`, `Mar`) | `--look 2d` |
+| Curiosidad de ciencia/animales/cuerpo | 2D ilustrado (mundo SVG propio + `GraficaBarras`, `Lupa`, `medida`, `dato`) o 3D | `--look 2d` |
+| "¿Qué pasaría si…?", ciudades, objetos, escala | 3D: `Lienzo3D` + `Persona3D`, `Ciudad`, `Camino`, `Coche` | `--look 3d` |
+| Cómo funciona algo por dentro (agua, tráfico, máquinas), 90–130 s | Maqueta: estilo `maqueta`, kit diorama (`Maqueta`, `Trafico`, `Corte`, `Etiqueta3D`, fichas) | estilo `maqueta` |
+| Tutorial, pasos, apps | Editorial: estilo `explicativo`, `titular` + `terminal`, `tarjeta`, `cursor`, `personaje` | estilo `explicativo` |
+| Dinero, objetos valiosos, comparar cantidades | 3D cálido: estilo `mesa`, `Mesa`, `Pila`, contador LCD | estilo `mesa` |
+
+## 2. Crea el video desde una base que ya renderiza
+
+```bash
+npx morfeo nuevo-video <id> --look 2d     # o --look 3d
+```
+
+Crea `guiones/<id>.mjs` y `escenas/Mundo<Id>.tsx` y lo registra en `componentes`. Renderízalo una vez tal cual para
+confirmar que todo funciona antes de cambiar nada.
+
+## 3. Escribe el guion con la estructura (no negociable)
+
+Resumen; el método completo (arquetipos de gancho, orden por retención, fallos comunes) está en `morfeo-guion`.
+
+1. **Gancho en los primeros 2 s**, en segunda persona o con una cifra imposible: "Imagina que…", "¿Y si tu…?", "Si tu…",
+   "Este es X. Pero…". El sujeto ya en pantalla. Nada de "hoy te voy a contar".
+2. **Una idea por escena, 2–5 s de voz.** Si dura más, que algo entre a media frase (`en: 'palabra'`).
+3. **Pregunta antes de revelar** ("¿Cuánto crees que pagó?") y la respuesta con número que cuenta (`dato`, `contador`) o golpe visual.
+4. **Texto en dos niveles**: subtítulo + `rotulo` corto en 2–4 escenas ("¿CUÁNTO *PAGÓ*?"). `claves: ['palabra']` en cada escena.
+5. **Datos pegados a las cosas**: `nombre` (con rol), `accion` ("▶ Te despiertas"), `dato`, `medida`, `contorno`, `trazo`.
+6. **Sube la apuesta** hacia el final.
+7. **Cierre que pide algo**: `{type: 'cta', pide: 'comenta', palabra: 'X'}` o `pide: 'comparte', a: '…'` o escena `eleccion`.
+8. Duración: ~30–65 s (maqueta 90–130 s). Series: `serie: 'NOMBRE · EP. 2'`.
+9. `title`, `descripcion` y `tags` para publicar (salen en `salida/<id>.txt`).
+
+Detalles que rompen videos si se olvidan:
+- `say` = lo que dice la voz (números **en letra**); `show` = subtítulo con cifras. **Con `show`, los `en: 'palabra'` se buscan
+  en el subtítulo**: si dice "1.560.000", `en: 'millón'` no existe → usa `en: '1.560.000'` o un tiempo. El render avisa con `!`.
+- Los momentos aceptan `'palabra+0.4'`, `'voz'`, `'fin-0.5'` o segundos.
+- Mundo 2D: `toma: {x, y, zoom, a: {...}}` por escena (punto del mundo de 2160×1920 que queda al centro).
+- Mundo 3D: la cámara va en el componente (`TOMAS: Toma3D[]`, una por escena). En vertical el plano general va en diagonal.
+- Un solo `Lienzo3D` por video. Nada de `useFrame` ni timers: todo depende de `t`.
+- Encuadre vertical en 3D (fov 38): a distancia d se ven ±0.19·d de ancho y ±0.34·d de alto; para que algo de ancho W
+  llene ~70 % del cuadro, d ≈ 3.7·W. Acomoda las cosas una detrás de otra, no lado a lado.
+- Etiquetas 3D cerca de la orilla se cortan: usa `lado: 'izq'`/`'der'` hacia el centro del cuadro.
+- No corras dos renders ni `hoja` pesadas a la vez: Morfeo espera su turno, pero procesos sueltos de Chrome ensucian cuadros.
+- Cuida los hechos: solo datos que puedas sostener; si dudas de una cifra, dila en general ("unas cinco semanas").
+
+## 4. Arma el mundo con el kit
+
+- 2D (dentro de `<svg>`): `Filtros`, escenarios, `Persona2D` (`expresion`: feliz, triste, enojado, sorpresa, miedo,
+  dormido, pensativo; `pose`: parado, caminar, señalar, brazosArriba, pensar, cruzado, sentado; `estados: [{en, expresion, pose}]`;
+  `habla: [[t0, t1]]`), `Multitud`, `Globo` (`en`, `hasta`), `ConoLuz`, `Paralaje`, gráficas (`GraficaBarras`, `GraficaLinea`,
+  `Comparacion`, `Lupa`).
+- 3D: `Lienzo3D` (`luz` dia/calida, `hora`, `etiquetas`), `Persona3D` (con cara y expresiones) o `Persona` (figura de maqueta),
+  `Ciudad`, `Camino`, `Coche`, `Trafico`, `Cuarto3D`, `Terreno`, `Tubo` (`agua` 0..1), `Arbol`, `Casa`, `Mesa`, `Pila`, `Modelo` (.glb).
+- Usa `escena`, `tEscena`, `inicios` y `cuando('palabra')` para que el mundo reaccione a la historia.
+
+## 5. Revisa, renderiza y mira el resultado
+
+```bash
+npx morfeo revisar <id>       # estructura (gancho, ritmo, preguntas, cierre)
+npx morfeo render <id>        # avisos `!` = palabra que no existe; arréglalos
+npx morfeo hoja <id>          # mira la hoja de cuadros (y --desde 8 --hasta 11 para un tramo)
+```
+
+Lista de comprobación antes de decir "listo" (míralo en la hoja, no lo supongas):
+- [ ] El primer cuadro ya tiene al sujeto y algo pasando.
+- [ ] Nada importante tapado por subtítulos, rótulos o la marca; texto dentro del cuadro.
+- [ ] Cada escena cambia algo visible cada 2–4 s.
+- [ ] Los datos aparecen cuando la voz los dice (sin avisos `!` en el render).
+- [ ] El cierre pide algo concreto.
+- [ ] `npx morfeo revisar <id>` sin avisos `!`.
+
+Para varios videos: `npx morfeo render` (los que falten). Si alguno falla, el lote sigue; corrige y
+`npx morfeo render --solo-fallidos`.