@damiangilgonzalez/harness 1.3.7

package/skills/vercel/references/cli-cookbook.md

@@ -0,0 +1,98 @@
+# Vercel CLI cookbook
+
+Copy-paste recipes. All read-only unless noted. Assumes `npm i -g vercel` (or `npx vercel`).
+
+## Link & first deploy
+
+```bash
+vercel link                  # associate the current dir with a project (writes .vercel/)
+vercel                       # preview deploy, prints a unique URL
+vercel --prod                # production deploy
+vercel dev                   # local emulation of functions + routing
+vercel pull                  # fetch project settings + env into .vercel/.env.* for local builds
+vercel inspect <url>         # details for a specific deployment
+vercel logs <url>            # runtime logs for a deployment
+```
+
+## Env var round-trip
+
+```bash
+vercel env ls                                   # which vars exist in which environments
+vercel env add API_URL production               # add to production (prompts for value)
+vercel env add API_URL preview                  # separate command — preview
+vercel env add LOCAL_ONLY development            # development MUST be its own command
+vercel env pull .env.local                      # pull the linked env into .env.local (overwrites)
+vercel env pull .env.local --environment=preview # pull a SPECIFIC environment
+vercel env rm API_URL preview                   # remove a var from one environment
+vercel env run -- npm run seed                  # run a command with project vars injected
+```
+
+Reminders:
+
+- You cannot mix `development` with `production`/`preview` in one `vercel env add`.
+- Vars added to production/preview/custom default to **sensitive** (write-only).
+- `vercel env pull` **overwrites** the target file for one environment — re-pull after changes.
+
+## Domains & aliases
+
+```bash
+vercel domains add example.com           # attach a domain to the current project
+vercel domains ls                        # list domains
+vercel domains inspect example.com       # config + record/nameserver status
+vercel domains add example.com --force   # move the domain off whatever project holds it
+vercel domains rm example.com            # detach (mutating)
+vercel alias set <deployment-url> staging.example.com  # point an alias at a deployment
+vercel dns ls example.com                # list DNS records (managed-domain case)
+```
+
+For DNS-record theory and registrar transfers, defer to the `domains-dns` skill.
+
+## Promote a preview to production
+
+A preview deployment is already built; promote it instead of rebuilding.
+
+```bash
+vercel ls                                # find the preview deployment URL
+vercel promote <deployment-url>          # promote that exact build to production
+vercel rollback <deployment-url>         # roll the production domain back to a prior deploy
+```
+
+## Skip redundant builds (monorepo)
+
+```json
+{ "ignoreCommand": "git diff --quiet HEAD^ HEAD -- ." }
+```
+
+Vercel cancels the build when `ignoreCommand` exits `0` (zero = skip).
+
+## Deployment-protection bypass for CI
+
+When CI must reach a protected preview, don't disable protection — send the bypass header.
+Configure "Protection Bypass for Automation" in project settings to get the secret, then:
+
+```bash
+curl -H "x-vercel-protection-bypass: $VERCEL_AUTOMATION_BYPASS_SECRET" \
+     "https://my-preview-xyz.vercel.app/api/health"
+```
+
+On Hobby, Standard Protection covers preview deployments and the generated deployment URLs; the
+production custom domain stays public.
+
+## System env vars (`VERCEL_*`, read-only)
+
+| Var | Value |
+| --- | --- |
+| `VERCEL` | `1` when running on Vercel |
+| `VERCEL_ENV` | `production` \| `preview` \| `development` |
+| `VERCEL_URL` | Deployment host (no protocol) |
+| `VERCEL_BRANCH_URL` | Git-branch deployment URL |
+| `VERCEL_PROJECT_PRODUCTION_URL` | Production domain |
+| `VERCEL_REGION` | Region the function is executing in |
+| `VERCEL_GIT_PROVIDER` | e.g. `github` |
+| `VERCEL_GIT_REPO_SLUG` | Repository slug |
+| `VERCEL_GIT_COMMIT_REF` | Branch/ref that triggered the deploy |
+| `VERCEL_GIT_COMMIT_SHA` | Commit SHA |
+| `VERCEL_GIT_COMMIT_MESSAGE` | Commit message |
+| `VERCEL_GIT_COMMIT_AUTHOR_LOGIN` | Author login |
+
+Read them in the app (`process.env.VERCEL_ENV`); never try to set them.

package/skills/vercel/references/vercel-json.md

@@ -0,0 +1,120 @@
+# `vercel.json` — full key catalog
+
+Static config for a Vercel project. Add `"$schema": "https://openapi.vercel.sh/vercel.json"` for
+editor autocomplete and validation. `vercel.ts` supports the **same** properties but runs at build
+time, so it can compute config from env vars or API calls.
+
+## Top-level keys (current)
+
+| Key | Type | Notes |
+| --- | --- | --- |
+| `$schema` | string | Set to `https://openapi.vercel.sh/vercel.json` for validation |
+| `buildCommand` | string | Overrides the framework build command |
+| `bunVersion` | string | Pin the Bun version used for builds |
+| `cleanUrls` | boolean | Drop `.html`/`.htm` extensions from paths |
+| `crons` | array | Scheduled invocations — **production only** (see below) |
+| `devCommand` | string | Command for `vercel dev` |
+| `fluid` | boolean | Fluid compute toggle (on by default for new projects since 2025-04-23) |
+| `framework` | string | Framework preset (e.g. `nextjs`); `null` for no preset |
+| `functions` | object | Per-path function config (see below) — cannot combine with legacy `builds` |
+| `headers` | array | Response headers by path |
+| `ignoreCommand` | string | Run before build; **exit 0 = skip/cancel the build** |
+| `images` | object | Image Optimization config |
+| `installCommand` | string | Overrides dependency install |
+| `outputDirectory` | string | Build output dir |
+| `public` | boolean | Expose source/logs publicly |
+| `redirects` | array | URL redirects (status changes the visible URL) |
+| `bulkRedirectsPath` | string | Path to a large redirects file |
+| `regions` | array | Default deployment regions |
+| `functionFailoverRegions` | array | Failover regions (Enterprise) |
+| `rewrites` | array | URL rewrites (URL stays, content swaps) |
+| `routes` | array | Low-level routing (prefer rewrites/redirects/headers) |
+| `trailingSlash` | boolean | Force/forbid a trailing slash |
+
+`functions` and the legacy `builds` are mutually exclusive — use `functions`.
+
+## `functions` object
+
+```json
+{
+  "functions": {
+    "api/**/*.ts": {
+      "runtime": "nodejs22.x",
+      "maxDuration": 60,
+      "regions": ["fra1", "iad1"],
+      "includeFiles": "data/**",
+      "excludeFiles": "tests/**",
+      "supportsCancellation": true
+    }
+  }
+}
+```
+
+| Key | Notes |
+| --- | --- |
+| `runtime` | Runtime identifier; default Node (Vercel Functions). Edge Functions are deprecated |
+| `memory` | **Not under Fluid** — set default memory/CPU in the dashboard instead |
+| `maxDuration` | Max wall-clock seconds per invocation; plan-bound (table below) |
+| `supportsCancellation` | Node only |
+| `includeFiles` / `excludeFiles` | Glob extra/omitted files in the function bundle |
+| `regions` | Where the function runs |
+| `functionFailoverRegions` | Enterprise failover |
+
+### Per-plan duration & memory
+
+| Plan | `maxDuration` default → ceiling | Default memory |
+| --- | --- | --- |
+| Hobby | 10s → 60s | 1024 MB |
+| Pro | 15s → 300s | 1024 MB |
+| Enterprise | 15s → 900s | 1024 MB |
+
+Memory defaults to 1024 MB; under Fluid the default is a dashboard setting, not a `vercel.json` key.
+
+## `crons`
+
+```json
+{ "crons": [{ "path": "/api/digest", "schedule": "0 * * * *" }] }
+```
+
+- Each entry needs a `path` (must start with `/`) and a `schedule` (cron expression).
+- Crons run **only on the production deployment** — never on preview.
+
+## `rewrites` / `redirects` / `headers`
+
+```json
+{
+  "redirects": [{ "source": "/old", "destination": "/new", "permanent": true }],
+  "rewrites": [{ "source": "/proxy/:path*", "destination": "https://api.example.com/:path*" }],
+  "headers": [
+    { "source": "/(.*)", "headers": [{ "key": "X-Frame-Options", "value": "DENY" }] }
+  ]
+}
+```
+
+- `redirects`: `permanent: true` → 308 (cacheable), `false` → 307. Changes the visible URL.
+- `rewrites`: URL stays in the address bar; different content/origin is served. Use for proxying.
+- `headers`: attach response headers per path.
+
+## `vercel.ts` example
+
+```ts
+import type { VercelConfig } from "@vercel/config";
+
+const config: VercelConfig = {
+  functions: {
+    "api/**/*.ts": {
+      maxDuration: process.env.SLOW_API === "1" ? 60 : 15,
+      regions: [process.env.PRIMARY_REGION ?? "fra1"],
+    },
+  },
+  crons: [{ path: "/api/digest", schedule: "0 * * * *" }],
+  cleanUrls: true,
+};
+
+export default config;
+```
+
+Use `vercel.ts` only when config must be *generated*; otherwise prefer the static `vercel.json`.
+
+For the full region identifier list (`fra1`, `iad1`, `sfo1`, …) consult the Vercel regions doc — they
+change over time and are not worth hard-coding here.

package/skills/vercel/scripts/verify.sh

@@ -0,0 +1,168 @@
+#!/usr/bin/env bash
+# verify.sh — lint a target vercel.json against the 2025-2026 platform rules.
+#
+# Usage:
+#   bash scripts/verify.sh [path/to/vercel.json]
+#
+# With no arg it discovers ./vercel.json (then a shallow search). If no vercel.json
+# exists anywhere in range, that is NOT a failure — exit 0 (read-only, no false alarm).
+#
+# Checks (FAIL = exit 1; WARN = advisory, still exit 0 if nothing failed):
+#   1. valid JSON
+#   2. FAIL if both `builds` and `functions` are present (mutually exclusive)
+#   3. FAIL if any `functions.*.memory` is set (Fluid caveat — memory is a dashboard setting)
+#   4. WARN if `$schema` is missing (lose autocomplete/validation)
+#   5. for each `crons[]`: FAIL if `path` is missing or does not start with `/`, or `schedule` missing
+#
+# Pure jq/node/python3 — no network, no auth, no mutation. Runs on macOS bash 3.2 and CI bash 5.
+set -euo pipefail
+
+if [[ -n "${NO_COLOR:-}" ]]; then YEL=""; GRN=""; RED=""; RST=""
+else YEL=$'\033[33m'; GRN=$'\033[32m'; RED=$'\033[31m'; RST=$'\033[0m'; fi
+warn() { printf '%s[warn]%s %s\n' "$YEL" "$RST" "$*"; }
+ok()   { printf '%s[ ok ]%s %s\n' "$GRN" "$RST" "$*"; }
+fail() { printf '%s[fail]%s %s\n' "$RED" "$RST" "$*"; }
+
+have() { command -v "$1" >/dev/null 2>&1; }
+
+# Resolve target.
+TARGET="${1:-}"
+if [[ -z "$TARGET" ]]; then
+  if [[ -f vercel.json ]]; then
+    TARGET="vercel.json"
+  else
+    TARGET=$(find . -maxdepth 2 -name 'vercel.json' -not -path '*/node_modules/*' 2>/dev/null | head -n1 || true)
+  fi
+fi
+
+if [[ -z "$TARGET" || ! -f "$TARGET" ]]; then
+  ok "no vercel.json found in range — nothing to verify"
+  exit 0
+fi
+
+# Need a JSON engine. Prefer node (rich logic), then python3. jq optional fallback for validity only.
+ENGINE=""
+if have node; then ENGINE="node"
+elif have python3; then ENGINE="python3"
+elif have jq; then ENGINE="jq"
+else
+  warn "no node/python3/jq available — cannot lint $TARGET (skipping, not a failure)"
+  exit 0
+fi
+
+FAILED=0
+
+if [[ "$ENGINE" == "jq" ]]; then
+  # jq-only: can only confirm validity. Use -e (some jq builds exit 0 on parse error without it).
+  if jq -e . "$TARGET" >/dev/null 2>&1; then
+    ok "valid JSON ($TARGET)"
+    warn "only jq available — skipping builds/memory/crons rules (install node or python3 for full lint)"
+  else
+    fail "not valid JSON ($TARGET)"; FAILED=1
+  fi
+  if [[ $FAILED -eq 0 ]]; then ok "all checks passed"; else fail "checks failed"; fi
+  exit "$FAILED"
+fi
+
+# Full lint via node or python3. The runner prints lines: "OK …", "WARN …", "FAIL …".
+run_node() {
+node - "$TARGET" <<'JS'
+const fs = require("fs");
+const path = process.argv[2];
+let cfg;
+try { cfg = JSON.parse(fs.readFileSync(path, "utf8")); }
+catch (e) { console.log("FAIL not valid JSON: " + e.message); process.exit(0); }
+console.log("OK valid JSON (" + path + ")");
+
+const hasBuilds = Object.prototype.hasOwnProperty.call(cfg, "builds");
+const hasFns = Object.prototype.hasOwnProperty.call(cfg, "functions");
+if (hasBuilds && hasFns) console.log("FAIL `builds` and `functions` are mutually exclusive — remove `builds`");
+
+if (hasFns && cfg.functions && typeof cfg.functions === "object") {
+  for (const [glob, val] of Object.entries(cfg.functions)) {
+    if (val && typeof val === "object" && Object.prototype.hasOwnProperty.call(val, "memory")) {
+      console.log("FAIL functions[\"" + glob + "\"].memory is set — under Fluid, memory is a dashboard setting, not vercel.json");
+    }
+  }
+}
+
+if (!Object.prototype.hasOwnProperty.call(cfg, "$schema")) {
+  console.log("WARN missing `$schema` — add \"https://openapi.vercel.sh/vercel.json\" for validation");
+}
+
+if (Object.prototype.hasOwnProperty.call(cfg, "crons")) {
+  const crons = cfg.crons;
+  if (!Array.isArray(crons)) {
+    console.log("FAIL `crons` must be an array");
+  } else {
+    crons.forEach((c, i) => {
+      if (!c || typeof c !== "object") { console.log("FAIL crons[" + i + "] is not an object"); return; }
+      if (typeof c.path !== "string" || c.path.length === 0) console.log("FAIL crons[" + i + "] missing `path`");
+      else if (c.path[0] !== "/") console.log("FAIL crons[" + i + "] path must start with `/` (got \"" + c.path + "\")");
+      if (typeof c.schedule !== "string" || c.schedule.length === 0) console.log("FAIL crons[" + i + "] missing `schedule`");
+    });
+  }
+}
+JS
+}
+
+run_python() {
+python3 - "$TARGET" <<'PY'
+import json, sys
+path = sys.argv[1]
+try:
+    with open(path) as f:
+        cfg = json.load(f)
+except Exception as e:
+    print("FAIL not valid JSON: %s" % e); sys.exit(0)
+print("OK valid JSON (%s)" % path)
+
+has_builds = "builds" in cfg
+has_fns = "functions" in cfg
+if has_builds and has_fns:
+    print("FAIL `builds` and `functions` are mutually exclusive — remove `builds`")
+
+if has_fns and isinstance(cfg.get("functions"), dict):
+    for glob, val in cfg["functions"].items():
+        if isinstance(val, dict) and "memory" in val:
+            print('FAIL functions["%s"].memory is set — under Fluid, memory is a dashboard setting, not vercel.json' % glob)
+
+if "$schema" not in cfg:
+    print('WARN missing `$schema` — add "https://openapi.vercel.sh/vercel.json" for validation')
+
+if "crons" in cfg:
+    crons = cfg["crons"]
+    if not isinstance(crons, list):
+        print("FAIL `crons` must be an array")
+    else:
+        for i, c in enumerate(crons):
+            if not isinstance(c, dict):
+                print("FAIL crons[%d] is not an object" % i); continue
+            p = c.get("path")
+            if not isinstance(p, str) or not p:
+                print("FAIL crons[%d] missing `path`" % i)
+            elif not p.startswith("/"):
+                print('FAIL crons[%d] path must start with `/` (got "%s")' % (i, p))
+            if not isinstance(c.get("schedule"), str) or not c.get("schedule"):
+                print("FAIL crons[%d] missing `schedule`" % i)
+PY
+}
+
+if [[ "$ENGINE" == "node" ]]; then OUT=$(run_node); else OUT=$(run_python); fi
+
+# Render results and set exit status.
+while IFS= read -r line; do
+  [[ -z "$line" ]] && continue
+  case "$line" in
+    OK\ *)   ok   "${line#OK }" ;;
+    WARN\ *) warn "${line#WARN }" ;;
+    FAIL\ *) fail "${line#FAIL }"; FAILED=1 ;;
+    *)       printf '%s\n' "$line" ;;
+  esac
+done <<EOF
+$OUT
+EOF
+
+if [[ $FAILED -eq 0 ]]; then ok "all checks passed (warnings are not failures)"
+else fail "one or more checks failed"; fi
+exit "$FAILED"

package/skills/video-a-superprompt/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: video-a-superprompt
+description: "Turns a reference video into a highly detailed recreation or inspiration prompt. Use when the user provides, mentions, uploads, links, or points to a video and asks to analyze the design, UI, animations, transitions, scroll interactions, typography, colors, assets, WebGL/Three.js, narrative, or section-by-section behavior, or to create a prompt or article that recreates the page, app, interaction, or motion system."
+tags: ["video-analysis", "prompt-engineering", "design"]
+profiles: [ui, full]
+---
+
+# De video a superprompt
+
+## Objetivo
+
+Convertir cualquier video de referencia utilizable en un prompt listo para construir que capture lo que el video muestra, como se mueve, como debe reconstruirse y que assets o material generado hacen falta. La salida por defecto es un unico prompt listo para pegar, salvo que el usuario pida un articulo, un pack de assets o una implementacion.
+
+## Flujo
+
+1. **Localiza el video fuente.**
+   - Acepta rutas locales, ficheros subidos, URLs, videos visibles en el navegador, assets de un articulo o material del repo.
+   - Si el video se referencia pero no es accesible, pide el fichero o la URL exactos antes de inventarte detalles.
+   - Si el usuario quiere una recreacion exacta, inspecciona el HTML/CSS/JS fuente o la pagina local conectada al video antes de escribir el prompt.
+
+2. **Inspecciona el video tecnicamente.**
+   - Para ficheros locales, ejecuta `ffprobe` para duracion, dimensiones, fotogramas por segundo, codec y tamano.
+   - Extrae fotogramas representativos con `ffmpeg`, favoreciendo los momentos clave de la linea de tiempo antes que miniaturas uniformes.
+   - Pasada rapida sugerida:
+     ```bash
+     ffprobe -v error -show_entries format=duration,size:stream=width,height,r_frame_rate -of json "$VIDEO"
+     mkdir -p /tmp/video-frames
+     ffmpeg -y -i "$VIDEO" -vf fps=1 /tmp/video-frames/frame-%03d.jpg
+     ```
+   - En videos largos o con mucho scroll, extrae ademas el principio, el medio, el final y los momentos de transicion visibles.
+
+3. **Analiza por capas.**
+   - **Historia**: proposito de la pagina o app, arco emocional, orden de secciones, transicion entre tiempos.
+   - **Pantalla y layout**: encuadre del viewport, rejillas, zonas pegajosas, tarjetas, medios, capas superpuestas, margenes, navegacion, pie.
+   - **Movimiento**: tiempos de revelado, easing, parallax, mascaras, secciones fijadas, scroll con scrub, estados hover y tap, movimiento ambiental en bucle, movimientos de camara.
+   - **Diseno visual**: tipografia, paleta, superficies, bordes, sombras, textura, iconografia, tratamiento de imagen y video.
+   - **Reconstruccion tecnica**: CSS y APIs nativas, IntersectionObserver, Web Animations API, GSAP ScrollTrigger, Lenis, Framer Motion / Motion One, Three.js / WebGL, canvas, scrub de `video.currentTime`, carruseles u otras librerias del dominio.
+   - **Accesibilidad y rendimiento**: movimiento reducido, comportamiento en movil, estados tactiles y de teclado, carga diferida, precarga de video, tope de densidad de pixeles, respaldos estaticos.
+
+4. **Planifica los assets.**
+   - Produce un mapa de assets. Incluye las URLs exactas cuando se aporten, nombres de fichero locales cuando se usen, o nombres de marcador cuando todavia haya que generarlos.
+   - Si hacen falta assets de IA, crea prompts separados para planchas de imagen, clips de video, elementos WebGL/canvas, posters, sprites, mascaras y capas de textura.
+   - Si el usuario nombra modelos o APIs concretos, conservalos exactamente en el prompt y separa los prompts de imagen de los de video.
+
+5. **Escribe el superprompt.**
+   - Usa un unico bloque `text` con cercas para el prompt listo para pegar, salvo que el usuario pida otro formato.
+   - Empieza por lo que hay que construir y el limite de la referencia: recreacion exacta frente a adaptacion inspirada.
+   - Incluye: mapa de assets, marca y contenido, lenguaje de diseno global, reglas de layout, anatomia seccion a seccion, sistema de movimiento, sistema de scroll, comportamiento del video, comportamiento WebGL/Three.js, requisitos responsive, accesibilidad y rendimiento, y antipatrones.
+   - Para cada seccion importante, especifica proposito, layout, detalles visuales, animacion, interacciones, comportamiento de scroll, eleccion de libreria o API, y respaldo para movimiento reducido.
+   - Evita frases vagas tipo "que quede bonito", "animacion parecida" o "transiciones agradables". Convierte el gusto en instrucciones concretas de construccion.
+
+6. **Verifica antes de dar por hecho.**
+   - Comprueba que todas las rutas y URLs de assets del prompt existen o estan claramente marcadas como marcadores.
+   - Si creaste capturas o fotogramas, confirma que los ficheros no estan vacios y son representativos.
+   - Si escribes un articulo o un artefacto del repo, respeta las instrucciones del espacio de trabajo local y manten el area de staging acotada.
+
+## Modos de salida
+
+- **Solo prompt**: entrega el prompt listo para pegar y, cuando ayude, un mapa de assets corto encima.
+- **Articulo**: crea `content.md` mas las evidencias locales de fotogramas y video, el manifiesto y los prompts.
+- **Brief de implementacion**: anade un plan de construccion y una lista de QA despues del prompt.
+- **Pack de generacion de assets**: separa los prompts en imagenes de fondo, clips de video, sprites/WebGL, posters y prompt final de pagina.
+
+## Liston de calidad
+
+- El prompt debe ser lo bastante largo como para reconstruir la interaccion sin haber visto el video original.
+- Debe preservar la secuencia, el ritmo y las peculiaridades notables del video.
+- Debe nombrar los mecanismos de movimiento exactos: seccion fijada, linea de tiempo con scrub, `video.currentTime`, capa de parallax, revelado por opacidad, transform, mascara, shader, campo de particulas, estado hover o fisica de carrusel.
+- Debe incluir siempre el comportamiento en movil y el de movimiento reducido.
+- Debe senalar que evitar, sobre todo secciones genericas de landing, manchas decorativas, material de archivo que no encaja, video con reproduccion automatica cuando hace falta scrub por scroll, y solapamiento de texto.
+
+## Referencias
+
+- Lee `references/superprompt-template.md` al escribir el prompt final de cero o cuando el usuario pida "el prompt detallado completo".

package/skills/video-a-superprompt/evals/cases.yaml

@@ -0,0 +1,32 @@
+skill: video-a-superprompt
+
+should_trigger:
+  - prompt: "Analiza este video de referencia y crea un prompt de recreacion."
+    why: "Disparador directo de video-a-superprompt."
+  - prompt: "Quiero un articulo que recree la interaccion de scroll de este video."
+    why: "Disparador directo de video-a-superprompt."
+  - prompt: "Extrae la tipografia y los colores de este video de una web."
+    why: "Disparador directo de video-a-superprompt."
+  - prompt: "Turn this reference video into a detailed recreation prompt."
+    why: "Disparador directo de video-a-superprompt."
+  - prompt: "Analiza seccion a seccion el comportamiento de esta pagina en el video."
+    why: "Disparador directo de video-a-superprompt."
+
+should_not_trigger:
+  - prompt: "Construye la landing sin ningun video de referencia."
+    route_to: "diseno-landing"
+    why: "Construir una landing sin video de referencia es el trabajo de diseno-landing, no de video-a-superprompt."
+  - prompt: "Escribe el copy de esta pagina desde cero."
+    route_to: "mejor-redaccion"
+    why: "Escribir el copy es el trabajo de mejor-redaccion, no de video-a-superprompt."
+  - prompt: "Revisa la accesibilidad de este formulario."
+    route_to: "mejor-accesibilidad"
+    why: "Revisar la accesibilidad es el trabajo de mejor-accesibilidad, no de video-a-superprompt."
+  - prompt: "Genera la paleta de colores del sistema."
+    route_to: "mejor-colores"
+    why: "Generar la paleta de colores es el trabajo de mejor-colores, no de video-a-superprompt."
+
+capability:
+  - scenario: "El usuario aporta un video de referencia y pide recrear su diseno."
+    must_include:
+      - "video"

package/skills/video-a-superprompt/references/superprompt-template.md

@@ -0,0 +1,87 @@
+# Video Superprompt Template
+
+Use this structure for a paste-ready prompt. Delete sections that do not apply, but keep section-by-section motion detail.
+
+```text
+Build [exact thing] based on the supplied reference video. Treat the video as [exact recreation / visual and motion inspiration]. The result should feel [tone], with [domain-specific visual language].
+
+ASSET MAP
+- Main video/reference: [path or URL]
+- Background images: [URLs/placeholders]
+- Scroll-scrub videos: [URLs/placeholders]
+- Posters/sprites/textures/WebGL assets: [URLs/placeholders]
+
+BRAND AND CONTENT
+- Brand/name:
+- Core headline:
+- Supporting copy:
+- Navigation:
+- CTA:
+- Footer:
+
+GLOBAL DESIGN SYSTEM
+- Visual style:
+- Typography:
+- Colors:
+- Layout grid and spacing:
+- Image/video treatment:
+- Texture/surface/shadow rules:
+- Explicit anti-patterns:
+
+MOTION SYSTEM
+- Overall motion feel:
+- Easing/duration:
+- Reveal rules:
+- Scroll rules:
+- Hover/tap/focus states:
+- Ambient loops:
+- Reduced-motion behavior:
+
+SECTION 1: [Name]
+- Purpose:
+- Layout:
+- Visual details:
+- Animation:
+- Interaction:
+- Scroll behavior:
+- Implementation notes:
+
+SECTION 2: [Name]
+- Purpose:
+- Layout:
+- Visual details:
+- Animation:
+- Interaction:
+- Scroll behavior:
+- Implementation notes:
+
+[Repeat for every visible beat/section in video order.]
+
+VIDEO AND SCROLL IMPLEMENTATION
+- If a video should scrub with scroll, use a pinned/sticky section and map scroll progress to video.currentTime.
+- Keep videos muted, playsInline, preload metadata/auto, object-fit cover, no controls unless user-facing playback is required.
+- Use GSAP ScrollTrigger or native requestAnimationFrame for precise pinned scroll timelines.
+
+WEBGL / THREE.JS IMPLEMENTATION
+- Use Three.js/WebGL only for real particles, 3D, shaders, or canvas scenes.
+- Cap pixel ratio, reduce density on mobile, pause when hidden/offscreen, and provide static fallback.
+
+RESPONSIVE REQUIREMENTS
+- Desktop:
+- Tablet:
+- Mobile:
+- Safe-area/text-overlap constraints:
+
+ACCESSIBILITY AND PERFORMANCE
+- prefers-reduced-motion:
+- Keyboard/focus states:
+- Lazy loading/preloading:
+- Video/poster fallbacks:
+- Performance caps:
+
+SUCCESS CHECK
+- First viewport must show:
+- During scroll:
+- At the final section:
+- The build fails if:
+```