@xmarts/genius-setup 1.16.0 → 1.17.0

package/hooks/genius_inject.py

@@ -16,6 +16,7 @@ Hard rules:
 """
 import json
 import os
+import shutil
 import sys
 import urllib.request
 
@@ -89,7 +90,7 @@ def _inject(cfg, prompt):
 # version dictated by the server (xma_genius.hook_pin_version, returned in the
 # inject response) and otherwise fall back to this bundled known-good pin — the
 # client never resolves the mutable `@latest` tag.
-PINNED_FALLBACK = "1.7.2"
+PINNED_FALLBACK = "1.17.0"
 
 
 def _pkg_spec(pin_version):
@@ -103,6 +104,45 @@ def _pkg_spec(pin_version):
     return "@xmarts/genius-setup@%s" % PINNED_FALLBACK
 
 
+def _resolve_npx():
+    """Absolute path to npx (npx.cmd on Windows), so a detached process whose PATH
+    was stripped (Windows / the VSCode extension host) can still launch the self-
+    update. PATH first, then the usual install locations; None if truly absent."""
+    exe = "npx.cmd" if os.name == "nt" else "npx"
+    found = shutil.which(exe) or shutil.which("npx")
+    if found:
+        return found
+    cands = []
+    if os.name == "nt":
+        appdata = os.environ.get("APPDATA", "")
+        pf = os.environ.get("ProgramFiles", r"C:\Program Files")
+        pf6432 = os.environ.get("ProgramW6432", pf)
+        nvm = os.environ.get("NVM_SYMLINK", "")
+        for b in (os.path.join(appdata, "npm"), os.path.join(pf, "nodejs"),
+                  os.path.join(pf6432, "nodejs"), nvm):
+            if b:
+                cands.append(os.path.join(b, "npx.cmd"))
+    else:
+        cands += ["/usr/local/bin/npx", "/opt/homebrew/bin/npx", "/usr/bin/npx",
+                  os.path.join(HOME, ".npm-global", "bin", "npx"),
+                  os.path.join(HOME, ".volta", "bin", "npx")]
+        try:
+            import glob
+            nvms = sorted(glob.glob(
+                os.path.join(HOME, ".nvm", "versions", "node", "*", "bin", "npx")))
+            if nvms:
+                cands.append(nvms[-1])
+        except Exception:
+            pass
+    for c in cands:
+        try:
+            if c and os.path.exists(c):
+                return c
+        except Exception:
+            pass
+    return None
+
+
 def _maybe_self_update(cfg, force_epoch=None, pin_version=None, mcp_epoch=None):
     """Keep the consultant on the SERVER-PINNED Genius package with ZERO action: at most
     once/day, silently re-run the installer in the background. New hooks, MCP
@@ -146,9 +186,55 @@ def _maybe_self_update(cfg, force_epoch=None, pin_version=None, mcp_epoch=None):
         if not forced and os.path.exists(SELF_UPDATE_STAMP) and (
                 time.time() - os.path.getmtime(SELF_UPDATE_STAMP)) < SELF_UPDATE_TTL:
             return
-        # Stamp FIRST so a failing/slow npx never causes a retry storm.
+        # Resolve npx to an ABSOLUTE path BEFORE anything else. A detached process
+        # with a stripped PATH (Windows / the VSCode extension host) can't find a
+        # bare "npx"; if we can't resolve it we must NOT burn the stamp, or the box
+        # can never self-heal (the Windows silent-failure bug). All logged.
+        log_path = os.path.join(HOME, ".genius", ".selfupdate.log")
+
+        def _log(msg):
+            try:
+                os.makedirs(os.path.dirname(log_path), exist_ok=True)
+                with open(log_path, "a") as fh:
+                    fh.write("%s %s\n" % (time.strftime("%Y-%m-%dT%H:%M:%S"), msg))
+            except Exception:
+                pass
+
+        npx = _resolve_npx()
+        if not npx:
+            _log("self-update SKIPPED: npx not resolvable (PATH + known dirs); will retry")
+            return  # no stamp -> retry next turn instead of getting stuck for a day
+        env = dict(os.environ)
+        env["GENIUS_TOKEN"] = token
+        base = cfg.get("base_url")
+        spec = _pkg_spec(pin_version)  # exact pinned version — never @latest
+        try:
+            logfh = open(log_path, "a")
+            logfh.write("%s self-update launch: %s via %s\n" % (
+                time.strftime("%Y-%m-%dT%H:%M:%S"), spec, npx))
+            logfh.flush()
+        except Exception:
+            logfh = open(os.devnull, "w")
+        try:
+            if os.name == "nt":
+                # Absolute npx.cmd through cmd.exe so a stripped PATH can't break it.
+                cmd = '"%s" -y %s' % (npx, spec)
+                if base:
+                    cmd += ' --base-url "%s"' % base
+                subprocess.Popen(cmd, shell=True, env=env, stdout=logfh, stderr=logfh,
+                                 stdin=subprocess.DEVNULL, creationflags=0x00000008)  # DETACHED_PROCESS
+            else:
+                args = [npx, "-y", spec]
+                if base:
+                    args += ["--base-url", base]
+                subprocess.Popen(args, env=env, stdout=logfh, stderr=logfh,
+                                 stdin=subprocess.DEVNULL, start_new_session=True)
+        except Exception as e:
+            _log("self-update launch FAILED: %s (will retry next turn)" % e)
+            return  # launch failed -> no stamp -> retry
+        # Stamp ONLY after a successful launch: a resolvable-but-unlaunchable box
+        # keeps retrying, while a launched (slow) npx never re-spawns every turn.
         try:
-            os.makedirs(os.path.dirname(SELF_UPDATE_STAMP), exist_ok=True)
             with open(SELF_UPDATE_STAMP, "w") as fh:
                 fh.write(str(int(time.time())))
             if force_epoch:
@@ -158,24 +244,7 @@ def _maybe_self_update(cfg, force_epoch=None, pin_version=None, mcp_epoch=None):
                 with open(MCP_EPOCH_STAMP, "w") as fh:
                     fh.write(str(int(mcp_epoch)))
         except Exception:
-            return
-        env = dict(os.environ)
-        env["GENIUS_TOKEN"] = token
-        base = cfg.get("base_url")
-        spec = _pkg_spec(pin_version)  # exact pinned version — never @latest
-        devnull = open(os.devnull, "w")
-        if os.name == "nt":
-            cmd = "npx -y %s" % spec
-            if base:
-                cmd += ' --base-url "%s"' % base
-            subprocess.Popen(cmd, shell=True, env=env, stdout=devnull, stderr=devnull,
-                             stdin=subprocess.DEVNULL, creationflags=0x00000008)  # DETACHED_PROCESS
-        else:
-            args = ["npx", "-y", spec]
-            if base:
-                args += ["--base-url", base]
-            subprocess.Popen(args, env=env, stdout=devnull, stderr=devnull,
-                             stdin=subprocess.DEVNULL, start_new_session=True)
+            pass
     except Exception:
         pass
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmarts/genius-setup",
-  "version": "1.16.0",
+  "version": "1.17.0",
   "description": "One-command, self-updating onboarding for Xmarts Genius (Brain MCP + per-turn injection + automatic session/time capture + presence heartbeat for honest time-tracking 'amarre' + plan/committee→Brain enforcement + CLAUDE.md protocol + MCP fan-out: provisions the consultant's granted MCP servers into Claude Code & Claude Desktop). Secret-free onboarding via single-use setup-token exchange. Installs once; self-updates daily so new tools/skills/features arrive with zero action.",
   "bin": {
     "genius-setup": "bin/genius-setup.js"

package/plugin/skills/cinematic-scroll-site/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: cinematic-scroll-site
+description: Construye sitios "cinematic 3D-scroll" award-winning (efecto Apple: un video que se scrubbea con el scroll como una sola toma de cámara) con la técnica REAL (canvas frame-sequence + Lenis/GSAP), plantilla de brief de un-prompt, y 10 verticales listos (producto de lujo, restaurante, real estate, portafolio, e-commerce, SaaS, agencia, gym...). USAR cuando el usuario pida un sitio cinematic, "3D scroll", "scroll-scrub", una landing premium con video hero, o un sitio para un negocio local. Los assets se generan con higgsfield-video; el gusto lo pone design-taste-frontend; el copy pasa por content-humanizer.
+---
+
+# Cinematic Scroll Site: la técnica real, no la del lead-magnet
+
+Base verificada (Brain #6649, scouts 2026-07-07). El efecto "el video se mueve con
+el scroll como una toma continua" es la firma de estos sitios. La mayoría lo hace mal.
+
+## Regla dura #1: NO se scrubbea un `<video>`
+
+Scrubbear `video.currentTime` con el scroll tartamudea, snapea a keyframes, y FALLA
+en Safari iOS (decodifica para playback, no para seek). Apple NO scrubbea un video:
+dibuja una SECUENCIA DE FRAMES en un `<canvas>`. Caso de producción que lo documenta:
+OPTIKKA (Codrops, 2025-10-16), que migró de `<video>` a frame-sequence justo por esto.
+
+La técnica correcta: `frame = round(scrollProgress * (n-1))`, y `ctx.drawImage(frame)`
+en un solo canvas pinneado a pantalla completa.
+
+## Paso a paso (build-ready)
+
+### 1. Genera el clip y extrae frames
+El clip cinematográfico se genera con `higgsfield-video` (Kling 3.0 default por costo;
+premium solo para el hero final). Luego:
+```bash
+ffmpeg -i clip.mp4 -vf "fps=30" png/frame_%03d.png
+ffmpeg -i png/frame_%03d.png -c:v libwebp -quality 80 webp/frame_%03d.webp
+```
+Target 20 a 60 KB por frame (147 frames a 40 KB = ~6 MB, presupuesto de hero sano).
+Exporta un set REDUCIDO (menos frames, menos resolución) para móvil.
+
+### 2. Un canvas pinneado + el helper oficial de GreenSock
+Nunca cambies el `src` de un `<img>` en scroll (flicker + reflow). Siempre `drawImage`
+a un canvas. Dimensiona el canvas por `devicePixelRatio` y calcula offsets cover-fit.
+```javascript
+gsap.registerPlugin(ScrollTrigger);
+
+function imageSequence(config) {
+  let playhead = { frame: 0 },
+      canvas = gsap.utils.toArray(config.canvas)[0],
+      ctx = canvas.getContext("2d"),
+      curFrame = -1,
+      onUpdate = config.onUpdate,
+      images,
+      updateImage = function () {
+        let frame = Math.round(playhead.frame);
+        if (frame !== curFrame) {
+          config.clear && ctx.clearRect(0, 0, canvas.width, canvas.height);
+          ctx.drawImage(images[frame], 0, 0);
+          curFrame = frame;
+          onUpdate && onUpdate.call(this, frame, images[frame]);
+        }
+      };
+  images = config.urls.map((url, i) => {
+    let img = new Image();
+    img.src = url;
+    i || (img.onload = updateImage); // dibuja el primer frame al cargar
+    return img;
+  });
+  return gsap.to(playhead, {
+    frame: images.length - 1,
+    ease: "none",
+    onUpdate: updateImage,
+    duration: images.length / (config.fps || 30),
+    paused: !!config.paused,
+    scrollTrigger: config.scrollTrigger
+  });
+}
+
+imageSequence({
+  urls: Array.from({ length: 147 }, (_, i) =>
+    `frames/frame_${String(i + 1).padStart(3, "0")}.webp`),
+  canvas: "#hero-canvas",
+  clear: true, // solo si los frames tienen transparencia; omítelo si son opacos full-bleed
+  scrollTrigger: { trigger: ".hero", start: "top top", end: "+=3000", scrub: true, pin: true }
+});
+```
+`end` largo = scrub más lento y cinemático. En React existe `@bsmnt/scrollytelling`
+con un `ImageSequenceCanvas` ya hecho (misma mecánica).
+
+### 3. Preload inteligente
+Primeros ~10 frames eager, el resto por cola en background, prefetch direccional
+(unos frames adelante al bajar, atrás al subir). Dibuja el primer frame en su `onload`.
+
+### 4. Smooth scroll (glue de UNA sola RAF)
+Verbatim del README oficial de Lenis. NO corras además tu propio `requestAnimationFrame`
+para Lenis (double-drive = jitter).
+```javascript
+const lenis = new Lenis();
+lenis.on("scroll", ScrollTrigger.update);
+gsap.ticker.add((time) => { lenis.raf(time * 1000); });
+gsap.ticker.lagSmoothing(0);
+```
+Alternativa: GSAP ScrollSmoother. Nunca los dos a la vez.
+
+## Plantilla de brief de un-prompt
+
+```
+Construye un sitio award-winning cinematic 3D-scroll para <MARCA>.
+VISUALS (higgsfield-video, std 1080p, aspecto 16:9, ~8s/clip, sin audio):
+  genera UNA hero image primero y pásala como referencia a CADA clip (consistencia).
+  <3 a 5 shots, UN movimiento de cámara por shot, numerados>.
+WEBSITE: scroll-scrub del hero como canvas frame-sequence (Lenis + GSAP), secciones
+  pinneadas: <lista de secciones>.
+DESIGN: <fondo> / <acento único> / <tipografía>.
+COPY TONE: <voz>, pocas palabras.
+Launch on localhost and verify <la animación> before telling me it's done.
+```
+Esa última línea (auto-verificación forzada) es nuestra disciplina, no un adorno.
+Ver `references/verticals.md` para los 10 briefs por vertical ya armados.
+
+## Consistencia y encadenado (con honestidad)
+
+- **Hero-image primero:** genera una imagen y úsala como referencia (`input_files`) en
+  cada clip. Best practice DOCUMENTADA de Seedance 2.0 ("faces, clothing, visual style
+  stay locked across shots").
+- **Personas recurrentes:** entrena un Soul ID una vez y reusa su `reference_id`
+  (más fuerte que una imagen suelta).
+- **Encadenar clips:** Seedance 2.0 SÍ acepta start + end frame ("Start & End Frames").
+  Encadenar 5 clips (last-frame de uno como start-frame del siguiente) para "una toma
+  continua sin cortes" es un truco best-effort, NO garantizado por Higgsfield. No lo
+  prometas al cliente. El nombre exacto del param end-frame del MCP no está documentado;
+  resuélvelo en runtime (probe / `extra_params`).
+
+## Defaults de costo (los créditos expiran)
+
+std 1080p, ~8s, sin audio por default. 4K SOLO para el render final. "Compress the
+videos for web" (~-90%). Genera 2 a 3 tomas SOLO del hero (el hero-scrub es ~80% del wow).
+
+## Iterar como director, no como developer
+
+Notas por sensación: "hazlo 20% más lento", "esta sección se siente plana, agrega una
+interacción de cursor sutil", "cambia la tipografía, se ve genérica". El agente traduce
+intención a código.
+
+## Deploy "un prompt más" (Cloudflare Pages, gratis)
+
+1. `git push` de los estáticos a un repo de GitHub.
+2. Dash Cloudflare, Workers & Pages, Create application, Pages, Connect to Git, autoriza
+   el repo.
+3. Build command en BLANCO (HTML plano), Build output directory = carpeta del HTML.
+4. Save and Deploy (30 a 60s, obtienes `proyecto.pages.dev`).
+5. Custom domains, agrega el dominio (si ya está en Cloudflare crea el CNAME solo).
+
+Gotchas: (1) un proyecto Git-integration NO se puede pasar luego a Direct Upload;
+(2) completa el paso de custom-domain en el dash ANTES de agregar el CNAME o da 522;
+(3) records CAA que no permitan Cloudflare bloquean el certificado.
+
+## GTM (empaquetable)
+
+Los verticales restaurante, realtor y gym son un entregable local de $2,000 a $5,000:
+construye un sample, muéstralo a 5 negocios, cobra. Nunca han visto un sitio así.
+
+## Referencia autoritativa (opcional, para el admin)
+
+Para que el agente escriba pin/scrub/refresh/cleanup de GSAP impecables, el admin puede
+sumar a la flota el skill OFICIAL de GreenSock (MIT, auditado seguro):
+`/plugin marketplace add greensock/gsap-skills`. Este skill ya trae la receta inline,
+así que funciona sin él; es un plus, no un requisito.
+
+## Cross-refs
+
+- Assets (imagen/video): `higgsfield-video`, y NanoBanana2 para keyframes.
+- Gusto y anti-slop de diseño: `design-taste-frontend` + el theme engine OKLCH.
+- Copy sin señales de IA: `content-humanizer`.
+- Finishing determinista de clips (grain, Ken Burns, transiciones): `remotion-video`.

package/plugin/skills/cinematic-scroll-site/references/verticals.md

@@ -0,0 +1,92 @@
+# 10 verticales cinematic 3D-scroll (briefs base)
+
+Cada uno: para quién, los shots (3 a 5, UN movimiento de cámara cada uno), las secciones
+pinneadas, y la dirección de diseño. Rellena marca, ciudad y cifras; genera la hero image
+primero y pásala como referencia a cada clip.
+
+## 1. Producto de lujo (relojes, joyería, audio, sneakers)
+- Shots: (1) orbit 360 lento del producto flotando en vacío negro, rim light dramático;
+  (2) macro fly-through sobre el detalle (dial, textura, costura); (3) exploded assembly,
+  el producto se arma desde componentes flotantes.
+- Secciones: hero con el nombre en tracking, historia, macro-detalles, vista técnica con
+  spec callouts, edición limitada + CTA de waitlist.
+- Diseño: fondo off-black, un acento (oro/champagne), serif display alto contraste + sans
+  minimal. Copy: callado, caro, muy pocas palabras.
+
+## 2. Experiencia / storytelling (turismo, expediciones, museos)
+- Shots encadenados (aquí sí conviene el chaining best-effort): un descenso o recorrido
+  por zonas, cada clip termina donde arranca el siguiente. HUD fijo (profundidad, tiempo).
+- Secciones: hero con pregunta, un dato por zona, specs, CTA de reserva.
+- Diseño: color-grade que evoluciona con el scroll, un acento luminoso, sans técnica con
+  micro-detalles tipo instrumento.
+
+## 3. Portafolio personal (creadores, freelancers, consultores)
+- Sube una foto tuya bien iluminada de frente como referencia de identidad en cada clip.
+- Shots: (1) orbit 360 alrededor de ti, brazos cruzados, rim light; (2) tú entre pantallas
+  holográficas con tu trabajo, push-in lento; (3) caminas hacia cámara, pose final.
+- Secciones: nombre en display gigante letra por letra, strip de stats que cuentan al
+  scroll, 3 pilares, grid de trabajo con hover, CTA + socials.
+- Diseño: fondo tinta, un acento, display condensado bold, grano sutil.
+
+## 4. E-commerce / streetwear (drops, merch, ediciones limitadas)
+- Shots: (1) modelo camina hacia cámara entre niebla, el viento mueve la tela; (2) spins
+  1:1 de cada prenda en maniquí invisible, 360 limpio; (3) macro de costura y cierre.
+- Secciones: hero scroll-scrub del walk + countdown, grid de producto (cards que autoplay
+  su spin en hover), manifiesto de calidad, captura de email para tallas agotadas.
+- Diseño: gris concreto + negro mate, un acento ácido, condensada brutalista.
+
+## 5. Restaurante / cafe / bar (LOCAL, vendible $2k a $5k)
+- Shots: (1) macro slow-motion de la proteína sobre fuego, brasas subiendo; (2) dolly lento
+  por el salón en hora dorada; (3) cenital de un plato emplatándose, vapor subiendo.
+- Secciones: hero full-bleed scrub del fuego, historia breve, menú en dos columnas con
+  precios, reservación con formulario de fecha/party-size.
+- Diseño: fondo casi negro, crema cálida, acento ámbar, grano de película, parallax lento.
+  Móvil: menú colapsa a una columna elegante. Usa las fotos reales del negocio.
+
+## 6. Real estate (realtors, desarrollos, rentas vacacionales, hoteles)
+- Shots encadenados en un tour continuo: (1) drone que curva alrededor de la torre al
+  atardecer; (2) del elevador al living; (3) cocina y suite principal; (4) terraza de noche,
+  alberca infinita reflejando el skyline.
+- Secciones: hero, strip de facts (recámaras/baños/m2), galería, amenidades con reveals,
+  precio, "Request a Private Showing" con card del agente.
+- Diseño: fondo tinta, acento champagne-gold, serif delgado, mucho whitespace. Usa las
+  fotos reales de la propiedad como start frames.
+
+## 7. Automotriz / producto grande (autos, drones, bikes, maquinaria)
+- Shots encadenados del producto moviéndose por terreno real, no en estudio: (1) reveal en
+  desierto al amanecer; (2) low tracking shot lanzándose; (3) cañón a velocidad; (4) modo
+  noche, solo su firma de luz.
+- Secciones: hero con el nombre ultrawide, stats que cuentan al scroll, diseño con macro
+  stills, sección night-mode, teaser de configurador, CTA de reserva.
+- Diseño: negro sobre negro, acento cian eléctrico, condensada ultrawide, motion blur sutil.
+
+## 8. SaaS / app (software, herramientas AI, startups)
+- Shots: (1) partículas de datos que se ensamblan en un dashboard flotante que "late";
+  (2) macro sobre charts holográficos, una anomalía roja se enciende; (3) el dashboard en
+  una laptop en oficina minimal luminosa, todo bajo control.
+- Secciones: hero donde el dashboard se construye al scroll, logo strip de social proof,
+  3 bloques de feature, contadores de métricas, screenshot real del producto en mockup de
+  navegador, tabla de pricing (tier medio destacado), FAQ, CTA final.
+- Diseño: hero casi negro que funde a blanco para el body, un acento violeta, sans
+  geométrica, cards glassmorphism. Combo de credibilidad: hero generado + screenshots reales.
+
+## 9. Agencia / estudio creativo
+- Shots: (1) tinta negra floreciendo en agua en slow motion, con destellos de oro;
+  (2) showreel: posters y pantallas con tipografía bold deslizándose por paredes de galería;
+  (3) siluetas de un equipo pequeño trabajando de noche, bokeh de ciudad por la ventana.
+- Secciones: hero con la tinta detrás del nombre en display enorme, manifiesto kinético
+  (una palabra por paso de scroll), grid de casos con hover-video, servicios en dos columnas
+  editoriales, equipo, footer sobredimensionado con CTA.
+- Diseño: negro puro + hueso, oro usado exactamente 3 veces en todo el sitio, mezcla de un
+  display brutalista con un serif refinado. Cursor = punto de oro con estela.
+
+## 10. Gym / fitness (LOCAL, vendible $2k+)
+- Shots: (1) atleta choca manos con tiza en gym oscuro, la nube de tiza florece en un haz de
+  luz cenital; (2) macro tracking por una barra cargada, textura de knurling y tiza;
+  (3) corredor en pista al amanecer, aliento visible, cámara baja y rápida al lado.
+- Secciones: hero scrub de la nube de tiza, filosofía (una línea por paso de scroll), grid
+  de programas con hover, coaches, strip de resultados con contadores, pricing (3 tiers,
+  medio destacado), horario + mapa + formulario.
+- Diseño: fondo carbón, tipo hueso, un acento rojo sangre, display industrial condensado,
+  grano y viñeta en toda la imagen. Móvil: programas en cards swipeables. Usa fotos reales
+  del espacio y su horario y precios.

package/plugin/skills/content-humanizer/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: content-humanizer
+description: Humaniza texto para que NADA que produzcamos parezca escrito por IA (cero em-dash, cero frases plantilla, cero paralelismo negativo). USAR siempre que se genere o revise texto que verá una persona (guion, correo, deck, binder, post, propuesta, prosa de un análisis) o cuando el consultor pida "humaniza esto", "¿suena a IA?", "quita los em-dash", "revisa señales de IA", o antes de enviar cualquier copy. Trilingüe ES/EN/PT. La red de seguridad es cf_slop_check en el MCP contentforge.
+---
+
+# Humanizer: cero señales de escritura por IA
+
+Regla NO negociable de Xmarts: nada que generemos (nosotros o cualquier
+consultor, en Claude Code, ContentForge, decks, binders, webapps, correos o
+prosa, en ES, EN o PT) debe parecer escrito por IA. El diferenciador de Xmarts
+es la calidad. Un texto con señales de IA nos abarata. Esta regla aplica a la
+ESCRITURA; la directriz hermana anti-AI-design cubre el diseño.
+
+## Prevención primero (lo más barato), linter después (la red)
+Escribir bien desde el principio cuesta menos que limpiar. El orden correcto es:
+1. Redactar plano y específico (ver reglas abajo).
+2. Pasar el texto por el gate: `cf_slop_check` (MCP `contentforge`) o
+   `cf slop-check` en CLI. Devuelve las señales encontradas con línea, categoría
+   y nota, más un veredicto CLEAN o TELLS.
+3. Reescribir cada ERROR y volver a checar. Los WARN son revisión humana.
+
+## Las señales que delatan a la IA (y qué hacer)
+- **Em-dash y en-dash como conector (— o –): jamás.** Usa coma, dos puntos, <!-- slop-lint-ignore -->
+  paréntesis o punto. Esta es la señal número uno.
+- **Frases plantilla**: "cabe destacar", "en un mundo cada vez más", "sumérgete", <!-- slop-lint-ignore -->
+  "it's important to note", "stands as a testament", "em conclusão", "é <!-- slop-lint-ignore -->
+  importante ressaltar". Bórralas y ve directo al punto.
+- **Paralelismo negativo**: "no solo... sino", "it's not X, it's Y", "não apenas... <!-- slop-lint-ignore -->
+  mas". Afírmalo en positivo.
+- **Regla de tres (tricolon)**: tres adjetivos o cláusulas en fila por ritmo.
+  Deja uno, el que importa.
+- **Atribución fantasma**: "algunos expertos", "some experts argue", "se dice <!-- slop-lint-ignore -->
+  que". Cita a alguien real o quítalo.
+- **Palabras bandera**: delve, tapestry, testament, seamless, boasts, tapeçaria, <!-- slop-lint-ignore -->
+  potenciar, desbloquear el potencial. Cámbialas por el sustantivo concreto. <!-- slop-lint-ignore -->
+
+## Cómo suena un texto humano
+- Sustantivos concretos sobre adjetivos. Cifras y hechos sobre superlativos.
+- Frases de largo variado. Punto final en vez de signo de exclamación.
+- Voz activa, sujeto claro, una idea por frase.
+- Si una frase se puede borrar sin perder información, bórrala.
+
+## Dónde ya está blindado
+- **ContentForge (reel)**: el pipeline corre el gate sobre el guion y la
+  narración ANTES de gastar en voz, imágenes o render. Un ERROR detiene el reel,
+  así que nunca se publica un video que se lea como IA.
+- **Website de Rubén**: build que FALLA si hay slop en el HTML enviado.
+- **Linter canónico**: `~/.genius/tools/ai-slop-lint` (y vendorizado en
+  ContentForge). Es la misma fuente de verdad trilingüe en todas partes.
+
+## Falsos positivos
+La lista ERROR es de alta precisión. Si algo legítimo se marca (un guion cita un
+em-dash de una fuente, por ejemplo), usa `allow` en el tool o `--allow` en CLI, o
+el comentario `slop-lint-ignore` en esa línea. Nunca bajes la precisión del
+ERROR para silenciar un caso.
+
+## Regla dura
+El linter es la red, no el primer filtro. Entrega texto que ya pasa porque se
+escribió bien, no porque se parcheó. Si vas a mandarle prosa a un consultor o a
+un cliente, checa primero.

package/plugin/skills/content-style-bible/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: content-style-bible
+description: Analiza y hace ingeniería inversa del ESTILO de un competidor con ContentForge (videos de YouTube, sitios web, miniaturas, diseños). USAR cuando el consultor pida estudiar/analizar/desmenuzar el estilo de un canal, video, thumbnail, landing o diseño; "cómo hace X sus videos", "analiza esta miniatura", "qué paleta/ritmo usa este canal", "reverse-engineer este estilo", "sácame un style guide de este video", "análisis de competidor" o mencione "style bible". Devuelve un reporte medido con score de honestidad. Servido desde el MCP contentforge; el consultor NUNCA toca terminal.
+---
+
+# Style Bible: análisis medido de estilo (ContentForge)
+
+El motor Style-Bible de ContentForge convierte cualquier fuente (un video de
+YouTube, un sitio web, una miniatura o una imagen de diseño) en un binder
+analítico medido, con el depth de un desglose editorial serio pero honesto por
+construcción: **el LLM nunca produce un número**. La paleta sale de k-means
+sobre pixeles reales, los cortes de un detector de escenas, la recurrencia de
+módulos de perceptual hashing, los tokens tipográficos del DOM. Lo cualitativo
+(tipografía, composición, tesis) se etiqueta como opinión, no se disfraza de
+dato.
+
+Es la forma ESTÁNDAR de auditar a un competidor o una pieza de contenido. Si el
+consultor pregunta "cómo logra este canal ese look" o "qué está haciendo bien
+esta miniatura", esto responde con evidencia, no con adjetivos.
+
+## Regla base: Xmarts sirve, el consultor consume
+El consultor pide en lenguaje natural, TÚ ejecutas vía el MCP `contentforge`
+(servido desde VPS). Cero instalación, cero git, cero terminal del consultor.
+
+## Las tres fuentes (lanes)
+| Fuente | Qué mide (todo medido) |
+|---|---|
+| **youtube_video** | Paleta (k-means), cortes por minuto, ritmo, recurrencia de módulos (dHash), y con transcript: pace en wpm + cold open verbatim |
+| **website** | Paleta y escala tipográfica leídas del DOM (getComputedStyle ponderado por área), familias de fuente, copy de CTAs |
+| **image / thumbnail** | Paleta (k-means), contraste WCAG local, y lectura cualitativa de visión (etiquetas, sin números) |
+
+## Cómo se usa (patrón async: analiza, sondea, recoge)
+Los análisis pueden tardar minutos (descarga, frames, visión). Por eso el flujo
+es asíncrono:
+
+1. **Lanzar**: `cf_style_analyze` con `ref` (URL de YouTube, URL de sitio, o
+   ruta/URL de imagen). El tipo se infiere; puedes forzarlo con `type`. Devuelve
+   un `bible_id` de inmediato, más learnings previos del Brain que aterrizan el
+   análisis.
+2. **Sondear**: `cf_style_status` con el `bible_id` hasta `done` (o `failed` con
+   una razón concreta: video privado, muro anti-bot, formato no disponible).
+3. **Recoger**: `cf_style_get` con el `bible_id` devuelve la verdad JSON, el
+   resumen de honestidad, y las rutas del reporte gold (HTML + Markdown + JSON).
+4. **Listar** lo reciente: `cf_style_list`.
+
+El reporte HTML es autocontenido (cero requests externos, specimens embebidos),
+con nueve secciones, badges de evidencia por dato, modelo de dos paletas WCAG, y
+la columna módulo→Remotion.
+
+## Cómo leer el reporte
+- **Barra de honestidad**: el porcentaje de datos medidos vs observados,
+  inferidos y de juicio. Un website suele medir alto (el DOM es exacto); un
+  thumbnail lleva más inferidos por diseño (la visión etiqueta, no mide). Eso es
+  una señal de calidad honesta, no un defecto.
+- **Badges por dato**: `measured` (una instrumento lo produjo, con su fuente),
+  `observed` (un artefacto real: un frame, una cita), `inferred` (una etiqueta
+  del LLM que cita evidencia medida), `judgment` (una opinión honesta).
+- **Library de módulos**: cada módulo recurrente cita frames reales y mapea a una
+  composición Remotion real, o dice "needs new composition" (nunca inventa un id).
+- **Reproduction Stack** (sección 08): la receta para reconstruir ese estilo con
+  las herramientas servidas (Opus 4.8 para guion, NanoBanana2 para imágenes,
+  Veo para video, Remotion para animación, ElevenLabs para voz).
+
+## De análisis a producción
+El Style Bible es el paso de INTELIGENCIA. Para convertir lo aprendido en una
+pieza propia, encadena con el skill `content-war-tank` (estrategia + guion +
+producción) usando el bible como brief de estilo. Nunca se copia: se aprende la
+gramática visual y se produce mejor.
+
+## Reglas duras
+- Si `cf_style_status` devuelve `failed`, lee la razón y díselo al consultor tal
+  cual (el motor no fabrica un reporte parcial que parezca real).
+- Los números del reporte son medidos o NULL, jamás inventados.
+- El reporte no lleva rastro del proceso interno: se entrega en voz neutra de
+  estudio.
+- Antes de mandarle prosa del análisis al consultor, pásala por el gate de
+  humanización (skill `content-humanizer` / `cf_slop_check`).

package/plugin/skills/content-war-tank/SKILL.md

@@ -18,6 +18,10 @@ Antes de idear nada, medir el terreno con ContentForge:
   canales/videos lideran, con qué formatos.
 - `cf_trends` → narrativas y temas en alza AHORA.
 - `cf_packaging_swaps` → títulos/miniaturas que convierten vs los que no.
+- **Style Bible** (`cf_style_analyze`, skill `content-style-bible`) → teardown
+  MEDIDO del video/canal/thumbnail líder del nicho: paleta, ritmo de cortes,
+  módulos recurrentes, tipografía. Aprende la gramática visual que gana, con
+  evidencia, para producir mejor sin copiar.
 - Salida: un brief de oportunidad con evidencia (qué ángulo está desatendido y por qué ganaría).
 
 ### Fase 2 — ESTRATEGIA (comparativa vs competidores)
@@ -32,6 +36,9 @@ Antes de idear nada, medir el terreno con ContentForge:
 - `cf_run` genera el guion con **claude-opus-4-8** (tier deep), alimentado por el
   brief de la Fase 1 — NO un guion genérico, uno anclado a lo que la data dijo que gana.
 - `cf_guards` → validar calidad/voz/claims antes de producir (fact-check con haiku).
+- **Humanización** (`cf_slop_check`, skill `content-humanizer`) → el guion y la
+  narración no deben leerse como IA (cero em-dash, cero frases plantilla). El
+  pipeline del reel ya bloquea si hay señales; checa antes para no perder el render.
 - `cf_script_get` → recuperar/versionar el guion aprobado.
 
 ### Fase 4 — STORYBOARD (gate humano obligatorio)
@@ -67,6 +74,21 @@ ElevenLabs propio (no gastar créditos de terceros en lo que ya tenemos gratis).
 - **animación** → Remotion
 - **voz** → ElevenLabs `eleven_multilingual_v2`
 
+## Bucle de suite — ContentForge ⇄ Genius/Brain (cableado, úsalo siempre)
+ContentForge NO opera aislado: es miembro pleno de la suite y se comunica con el Brain.
+- **ANTES de generar** un guion/estrategia: `cf_brain_query "<tema/nicho/ángulo>"` →
+  trae learnings previos (qué funcionó, hooks, performance) para GROUNDING. También
+  el consultor puede usar `query_knowledge` (MCP beesmart_genius) con
+  `discipline="content_creation"`.
+- **DESCUBRIR qué herramienta usar**: `cf_genius_capabilities` → ContentForge VE todo
+  el catálogo Genius/Brain (81+ skills: NanoBanana2, Veo, Remotion, ElevenLabs, l10n…)
+  para rutear cada etapa a la herramienta óptima.
+- **DESPUÉS de una interacción valiosa** (un guion que funcionó, un insight competitivo,
+  un hook ganador): `cf_brain_capture` → alimenta el Brain (disciplina content_creation,
+  queda draft → lo tría el LLM-judge). Así CADA pieza mejora la inteligencia del sistema.
+
+El resultado: la máquina aprende de sí misma y de toda la suite en cada ronda.
+
 ## Principios no negociables
 1. **Data antes que creatividad** — sin Fase 1+2, no se produce.
 2. **Comparativa vs competidores** en cada brief (qué hacen los que ganan, dónde el gap).

package/plugin/skills/contentforge/SKILL.md

@@ -43,6 +43,8 @@ pnpm doctor    # DEBE dar GREEN 8/8 antes de servir
 | Render de composición | `pnpm cf render --comp KineticQuote --props f.json --out x.mp4` |
 | **Dashboard visual** | `pnpm cf ui` → http://localhost:4577 (library/detail/formulas/runs) |
 | Inteligencia competitiva (velocity + trend radar, zero-key) | `cf intel add-channel/poll/trends` |
+| **Style Bible** (analizar el estilo de un video/canal/web/thumbnail) | `cf_style_analyze` → `cf_style_status` → `cf_style_get` (skill `content-style-bible`) |
+| **Humanizar / revisar señales de IA** en cualquier texto | `cf_slop_check` o `cf slop-check` (skill `content-humanizer`) |
 | Costos de corridas (reales o NULL, nunca fabricados) | `pnpm cf runs` |
 
 ## Flujo recomendado (calidad máxima)
@@ -52,8 +54,46 @@ generate` + `hooks pick` (el hook decide la retención) → 4. `cf factcheck`
 6. voz con `elevenlabs-voiceover` → 7. `cf render`/`pipeline` → 8. preview
 aprobado ANTES del render final.
 
+## Superficie servida (MCP `contentforge`)
+El consultor NO tiene el repo. Consume ContentForge como un MCP servido desde
+VPS (`mcp__contentforge__*`), no con `pnpm cf`. Las tools clave:
+- **Inteligencia**: `cf_intel_channel`, `cf_intel_leaderboard`, `cf_trends`,
+  `cf_packaging_swaps`, `cf_hook_library`, `cf_pacing`.
+- **Style Bible** (análisis de estilo medido): `cf_style_analyze` (async, devuelve
+  `bible_id`), `cf_style_status`, `cf_style_get`, `cf_style_list`.
+- **Humanización**: `cf_slop_check` (señala em-dash y frases de IA en cualquier
+  texto; ES/EN/PT).
+- **Suite Genius/Brain**: `cf_brain_query` (consume learnings), `cf_brain_capture`
+  (alimenta el Brain), `cf_genius_capabilities` (ve todo el catálogo).
+- **Estado y datos**: `cf_status`, `cf_projects`, `cf_script_get`, `cf_bundles`,
+  `cf_guards`. Orquestación completa vía `cf_run` (allowlist).
+
+## Cuándo sugerir o usar ContentForge (uso transparente)
+Si el consultor plantea algo que ContentForge resuelve, ofrécelo o úsalo de una
+vez, de forma transparente (no le hagas pensar en la herramienta):
+- "¿cómo hace X sus videos?", "analiza este canal/thumbnail/landing", "qué estilo
+  usa" → **Style Bible** (`content-style-bible`).
+- "hazme un video", "guion para…", "anima este artículo", "hooks para…" →
+  pipeline de producción (`content-war-tank` para lo estratégico).
+- "¿qué está funcionando en el nicho?", "temas en alza" → inteligencia
+  (`cf_intel_*`, `cf_trends`).
+- cualquier texto que vaya a salir (correo, deck, post, propuesta) → pásalo por
+  **humanización** (`cf_slop_check`) antes de entregar.
+El consultor no instala nada: la herramienta ya está servida a su cuenta.
+
+## Acceso: quién lo tiene y cómo dar más
+ContentForge está servido y con acceso ya otorgado a Tyra, Ralph, Daniela y
+Rubén (verificado: el manifest de cada uno resuelve el server `contentforge`).
+Para habilitarlo a MÁS consultores, un admin crea un grant en Genius: un registro
+`xma.mcp.access` con `mcp_server_id` = server `contentforge`, `consultant_id` =
+el consultor (usa su ficha CANÓNICA), `effect` = `grant`, `active` = true. El
+manifest converge solo y la flota lo recibe sin que el consultor haga nada. El
+skill `genius-operator` tiene el contrato completo.
+
 ## Reglas duras
 - `pnpm doctor` GREEN antes de cualquier sesión de trabajo.
+- **Humanización obligatoria**: toda prosa que vea una persona pasa por
+  `cf_slop_check` antes de entregar (cero em-dash, cero frases de IA).
 - Fact-check obligatorio antes de publicar (claims con receipts o fuera).
 - Los costos que reporta `cf runs` son reales o NULL — jamás inventar números.
 - Guía ilustrada completa: `docs/guide/index.html` del repo (paso a paso con

package/plugin/skills/reasoning-discipline/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: reasoning-discipline
+description: Eleva a CUALQUIER modelo (Opus/Sonnet/Haiku/Fable) a operar con la disciplina de un modelo fuerte, vía 5 compuertas (scoping, evidencia, adversarial, verificación, reporte) + ruteo por modelo/esfuerzo. USAR antes de una tarea multi-paso difícil, un build, una auditoría, una migración, o cuando el usuario pida "modo riguroso", "fable mode", "piensa/razona con disciplina", "no me falles", "verifica antes de terminar", o cuando vayas a delegar a subagentes. Es la versión de UN-solo-agente del protocolo de comité.
+---
+
+# Reasoning Discipline: el proceso es el foso, no el modelo
+
+Regla de fondo (validada, Brain #6648): no puedes quedarte con la INTELIGENCIA de
+un modelo, pero sí con su PROCESO. Lo que produce salidas confiables es el harness,
+las compuertas y los loops, no el modelo. Esta disciplina eleva a un modelo barato,
+pero NO cambia su capacidad de base: no la sobre-vendas como un upgrade de inteligencia.
+
+Cárgala cuando la tarea sea cara de equivocar. Para trabajo trivial, no estorbes.
+
+## Las 5 compuertas (no las saltes)
+
+1. **SCOPING (antes de tocar nada).** No solo listar pasos: hacer de abogado del
+   diablo sobre lo desconocido. ¿Qué podría salir mal? ¿Qué supuestos no verifiqué?
+   Escribe el plan por etapas, numeradas, cada una con su condición de "pasa".
+2. **EVIDENCIA antes de razonar.** Lee el archivo, corre el grep, mira el esquema
+   real ANTES de teorizar. No razones sobre lo que crees que dice el código; ábrelo.
+3. **RAZONAR ADVERSARIALMENTE.** Ataca tu propia solución. ¿Qué caso la rompe?
+   ¿Qué cifra inventé? ¿Qué claim no es objetivamente verificable? Ante la duda,
+   asume que está mal hasta probar lo contrario.
+4. **VERIFICAR antes de declarar hecho.** Cada etapa define una condición que un
+   ARTEFACTO EXTERNO satisface (un test que pasa, un grep que devuelve la línea, un
+   `execute_orm` que da el número, un screenshot que se ve bien). "Se ve bien" no es
+   verificación; un artefacto sí. Re-verifica cada "listo" antes de decirlo.
+5. **REPORTAR / CALIBRAR.** Di qué falló, qué quedó sin verificar, qué es supuesto
+   vs. hecho. Honestidad sobre impresión. El reporte es parte del trabajo.
+
+Esto es el `feedback_committee_operating_protocol` en formato de un-solo-agente.
+Cuando la tarea amerite paralelismo o red-team, escala al comité (Workflow).
+
+## Principios operativos (del system prompt filtrado de Fable 5)
+
+Fuente CC0 pública (`asgeirtj/system_prompts_leaks`, corroborada por
+`jujumilk3/leaked-system-prompts`). Citar como filtrado, no confirmado por Anthropic.
+Cuatro reglas listas para usar:
+
+- **Verifica antes de confiar en la memoria.** "El reconocimiento parcial del training
+  no es conocimiento actual." Si lo recuerdas pero no lo comprobaste, compruébalo.
+- **Comprueba que el archivo exista.** Que el prompt implique que un archivo está
+  presente no significa que lo esté (el usuario pudo olvidar subirlo). Revisa tú mismo.
+- **Responde primero, pregunta después.** Atiende una consulta ambigua ANTES de pedir
+  aclaración. Máximo UNA pregunta por respuesta.
+- **Escala el esfuerzo a la tarea.** 1 llamada de herramienta para un dato simple,
+  3 a 5 para una tarea media, 5 a 10 para research o comparación honda.
+
+## Calibración de esfuerzo (importante)
+
+Más esfuerzo NO es siempre mejor. El esfuerzo bajo de un modelo top suele igualar al
+esfuerzo alto del tier siguiente. Subir a `xhigh`/`max` a veces EMPEORA: el modelo se
+sobre-piensa y se contradice. Default sensato: `high`. Sube solo si la tarea lo exige
+y estás dispuesto a pagar la latencia y el riesgo de overthinking.
+
+## Ruteo de modelo (delega el trabajo mecánico al tier barato)
+
+Palanca NATIVA de Claude Code (sin código):
+- `CLAUDE_CODE_SUBAGENT_MODEL` rutea TODOS los subagentes a un tier barato.
+- Cada subagente acepta el campo `model:` (incluido `inherit`).
+
+Policy de delegación:
+| Trabajo | Tier | Por qué |
+|---|---|---|
+| Razonamiento real, diseño, review de código, síntesis | Opus / Fable | Necesita juicio |
+| Variantes creativas, transformaciones con contexto | Sonnet | Buen costo/juicio |
+| Bulk mecánico: extracción, clasificación, sweeps, scouts | Haiku | ~3× más barato/token |
+
+Empareja el tier a la DIFICULTAD de la etapa, no al hábito.
+
+**Corrección de honestidad (no propagar el mito).** La frase de la comunidad
+"orquestador Opus + scouts Haiku = misma calidad, 3× más barato" NO tiene benchmark.
+El dato publicado de Anthropic (`anthropic.com/engineering/multi-agent-research-system`)
+es Opus-líder + Sonnet-subagentes = +90.2% en su eval de research, a ~15× MÁS tokens.
+O sea: el patrón orquestador-worker COMPRA calidad a mayor costo de tokens. "Haiku
+~3× más barato por token" es cierto; el combinado "misma calidad Y 3× más barato" no.
+Cuando cites el fundamento de nuestros comités, usa el número real (Opus+Sonnet,
++90.2%, 15× tokens), nunca el mito del ahorro.
+
+## Endurecer una compuerta con un hook (opcional)
+
+Una regla enforzada por un hook real vence a la prosa. Igual que el `ai-slop-lint`
+que falla el build, se puede enforzar una compuerta (p. ej. "un test nunca nombra una
+ruta de datos productiva") con un hook `PostToolUse` que bloquee la violación. Patrón:
+un solo gate mecánico, no todo el skill. Si vas a construir uno, documenta qué cazá,
+qué salta y qué NO cubre (los blind spots) en el propio hook.
+
+## Al cerrar
+
+Si esto fue un plan o un comité, captura sus perspectivas al Brain (`capture_learning`)
+antes de terminar. El análisis de un plan es conocimiento durable; perderlo es el error.