@xmarts/genius-setup 1.16.0 → 1.16.1

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.16.1"
 
 
 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.16.1",
   "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/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