---
type: SOP
asset_id: SOP-MTX-MatriX-BuildPagesHub-v01
version: v01
status: Activo
owner: Victor Heredia
sherpa_owner: Jay
ratificador: Victor Heredia
fecha_creacion: 2026-07-16
intellibank: IB-MTX-MatriX
proposito: >
  Procedimiento y script del build de MatriX: convierte las páginas canónicas
  Pages/PG-MTX-*.md en el bloque generado del MatriX-Hub-v01.html. Garantiza
  la regla de FUENTE ÚNICA (antídoto #3 del MasterPlan): el contenido se edita
  SOLO en Pages/; el hub se regenera, nunca se edita a mano.
nota_sync: >
  El script vive EMBEBIDO en este markdown a propósito — la sync del vault
  se come archivos .js/.py sueltos (caso BZ-EL-BuzonScanner). No extraerlo
  a un archivo permanente dentro del vault. Destino formal futuro: skill
  sk-mtxbuild en el plugin (repo git, fuera del vault).
tags: [SOP, MTX, MatriX, build, fuente-unica]
---

# SOP · Build MatriX (Pages/ → Hub)

## Reglas
1. **El contenido canónico vive en `Pages/PG-MTX-*.md`** (plantilla: `PG-MTX-Plantilla-v01`). El hub NUNCA se edita a mano en el bloque `__PG_BUILD__` ni en páginas que ya tienen PG-.
2. El build **sobreescribe** en el hub las páginas con PG- canónica (por `nodo_map` → id del hub) y marca estado **📄**; conserva del hub la familia, ícono y conexiones base.
3. Correr el build **después de cada tanda de siembra** y antes de cualquier revisión de Victor.
4. Páginas nuevas fuera del MAP: primero se dan de alta en `MAP-MTX-MatriX-IndiceEstructura-v01` y en el diccionario MAPID del script.
5. **Plantilla obligatoria (lección 22-jul, caso D8):** el build solo parsea secciones numeradas (`## 1 ·` … `## 6 ·`). Una página con encabezados libres compila "en éxito" pero queda **vacía en el hub** (n1/n2/n3 = 0c). Regla: TODA página PG-, incluidas las 🔒 internas, usa la plantilla canónica; el warning de calidad es revisar los conteos `n1/n2/n3` en la salida del build — un `0c` es bandera roja.
6. **Build público (antídoto #5):** el artefacto que se comparte fuera de EmpowerLabs es `MatriX-Hub-Publico-v01.html`, generado por el segundo script de este SOP. Excluye **físicamente** (no con CSS/JS) las páginas `pub:false` y todo el nivel N3. El `MatriX-Hub-v01.html` interno NUNCA se comparte fuera — su "Modo cliente 👁" es solo un toggle de UI, el contenido sigue en el fuente.

## Cómo correrlo (lo hace cualquier SherpaX)
1. Copiar el script de abajo a `/tmp/mtxbuild.py`.
2. `python3 /tmp/mtxbuild.py <ruta a IB-MTX-MatriX>`
3. Verificar la salida (una línea ✅ por página) y que el hub reporte "Hub actualizado".
4. Validación rápida: extraer el `<script>` del hub y correr `node --check`.

## El script (v01 · 2026-07-16)

```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Build MatriX: Pages/PG-MTX-*.md -> MatriX-Hub-v01.html (bloque __PG_BUILD__)."""
import re, os, sys, json, glob, datetime

BASE = sys.argv[1] if len(sys.argv)>1 else "."
PAGES = os.path.join(BASE, "Pages")
HUB   = os.path.join(BASE, "MatriX-Hub-v01.html")

# nodo_map (MAP #) -> id de página en el hub
MAPID = {"0.3":"rutaimpl","0.4":"rutaing","0.5":"vistarol",
 "1.1":"paraguas","1.2":"mapa","1.3":"stack","1.4":"sooi",
 "2.1":"hiorg","2.2":"worxos","2.3":"ibx","2.4":"worxlab","2.5":"worxeco","2.6":"triplebox",
 "3.1":"sherpax","3.2":"ultrasherpax","3.3":"sherpateamsx","3.4":"braincodes","3.5":"bcdistiller",
 "3.6":"decisionengine","3.7":"hyperloopx",
 "4.1":"intellibanks","4.2":"corpbrainos","4.3":"orgkernel","4.4":"capacoord","4.5":"skillseco",
 "5.1":"kitpnp","5.2":"rally","5.3":"empowerscan","5.4":"orgibx","5.5":"soporte",
 "6.1":"worxway","6.2":"xdoc","6.3":"capacidades","6.4":"gobernanza",
 "7.1":"mpb","7.2":"factoryinstance","7.3":"metafactory","7.4":"monex","7.5":"comunidades","7.6":"r100x",
 "8.1":"factorias","8.2":"directorx","8.3":"bmf","8.4":"casosvivos"}

def frontmatter(txt):
    m = re.match(r'^---\n(.*?)\n---\n', txt, re.S)
    d = {}
    if m:
        for line in m.group(1).splitlines():
            mm = re.match(r'^(\w[\w_]*):\s*(.*)$', line)
            if mm: d[mm.group(1)] = mm.group(2).strip().strip('"')
    return d, txt[m.end():] if m else txt

def sections(body):
    """Divide por '## N · Título' -> {N: contenido}"""
    out = {}
    parts = re.split(r'^## (\d+) ·[^\n]*$', body, flags=re.M)
    for i in range(1, len(parts)-1, 2):
        out[parts[i]] = parts[i+1].strip()
    return out

def strip_comments(s): return re.sub(r'<!--.*?-->', '', s, flags=re.S).strip()

def inline(s, linkmap):
    s = s.replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')
    # restaurar details ya se maneja aparte; aquí solo inline md
    def wl(m):
        tgt = m.group(1).split('|')[0].strip()
        pid = linkmap.get(tgt)
        if pid: return '<span class="conn" style="padding:1px 8px;font-size:12px" onclick="go(\''+pid+'\')">'+tgt.replace('PG-MTX-','').replace('-v01','')+'</span>'
        return '<code>'+tgt+'</code>'
    s = re.sub(r'\[\[([^\]]+)\]\]', wl, s)
    s = re.sub(r'\*\*([^*]+)\*\*', r'<b>\1</b>', s)
    s = re.sub(r'(?<!\*)\*([^*\n]+)\*(?!\*)', r'<i>\1</i>', s)
    s = re.sub(r'`([^`]+)`', r'<code>\1</code>', s)
    return s

def md2html(md, linkmap):
    md = strip_comments(md)
    html, buf, mode = [], [], None
    def flush():
        nonlocal buf, mode
        if not buf: return
        if mode=='ul': html.append('<ul>'+''.join('<li>'+x+'</li>' for x in buf)+'</ul>')
        elif mode=='ol': html.append('<ol>'+''.join('<li>'+x+'</li>' for x in buf)+'</ol>')
        else: html.append('<p>'+' '.join(buf)+'</p>')
        buf, mode = [], None
    for ln in md.splitlines():
        l = ln.rstrip()
        if not l.strip(): flush(); continue
        m_ul = re.match(r'^\s*[-*] (.*)$', l)
        m_ol = re.match(r'^\s*\d+\. (.*)$', l)
        if m_ul:
            if mode!='ul': flush(); mode='ul'
            buf.append(inline(m_ul.group(1), linkmap))
        elif m_ol:
            if mode!='ol': flush(); mode='ol'
            buf.append(inline(m_ol.group(1), linkmap))
        elif l.startswith('> '):
            flush(); html.append('<div class="anal">'+inline(l[2:], linkmap)+'</div>')
        else:
            if mode in ('ul','ol') and re.match(r'^\s{2,}', ln):
                buf[-1] += ' ' + inline(l.strip(), linkmap); continue
            if mode in ('ul','ol'): flush()
            mode = 'p'; buf.append(inline(l, linkmap))
    flush()
    return ''.join(html)

def parse_tarjeta(s):
    one = re.search(r'\*\*¿Qué es en una frase\?\*\*\s*(.+)', s)
    met = re.search(r'\*\*Metáfora:\*\*\s*(.+)', s)
    clean = lambda t: re.sub(r'\s+',' ',t).strip()
    return (clean(one.group(1)) if one else "", clean(met.group(1)) if met else "")

def parse_casos(s, linkmap):
    s = strip_comments(s); casos=[]
    for m in re.finditer(r'^\d+\.\s+(.*?)(?=^\d+\.|\Z)', s, re.S|re.M):
        item = re.sub(r'\s+',' ',m.group(1)).strip()
        mt = re.match(r'\*\*(.+?)\*\*\s*(.*)$', item)
        if mt: casos.append({"t":re.sub(r'[.·:]\s*$','',mt.group(1)).strip(),"d":inline(mt.group(2),linkmap)})
        elif item: casos.append({"t":"Caso","d":inline(item,linkmap)})
    return casos

def parse_quiz(s, linkmap):
    s = strip_comments(s); quiz=[]
    for m in re.finditer(r'^\d+\.\s+\*\*(.+?)\*\*\s*<details><summary>[^<]*</summary>(.*?)</details>', s, re.S|re.M):
        q = re.sub(r'\s+',' ',m.group(1)).strip()
        a = re.sub(r'\s+',' ',m.group(2)).strip()
        quiz.append({"q":inline(q,linkmap),"a":inline(a,linkmap)})
    return quiz

# ── pasada 1: linkmap asset_id -> hub id ──
files = [f for f in sorted(glob.glob(os.path.join(PAGES,"PG-MTX-*.md"))) if "Plantilla" not in f and "PilaWORX" not in f]
linkmap = {}
metas = {}
for f in files:
    fm, body = frontmatter(open(f,encoding="utf-8").read())
    nid = MAPID.get(fm.get("nodo_map","").strip('"'))
    if not nid:
        print(f"⚠️  {os.path.basename(f)}: nodo_map '{fm.get('nodo_map')}' sin mapeo — omitida"); continue
    linkmap[fm.get("asset_id", "")] = nid
    metas[f] = (fm, body, nid)

# ── pasada 2: generar overrides ──
out = []
for f, (fm, body, nid) in metas.items():
    sec = sections(body)
    ttl = re.search(r'^# (.+)$', body, re.M)
    one, meta = parse_tarjeta(sec.get("1",""))
    o = {"t": ttl.group(1).strip() if ttl else nid,
         "st": "📄", "src": os.path.basename(f),
         "one": inline(one, linkmap), "meta": inline(meta, linkmap),
         "n1": md2html(sec.get("2",""), linkmap),
         "n2": md2html(sec.get("3",""), linkmap),
         "n3": md2html(sec.get("4",""), linkmap),
         "casos": parse_casos(sec.get("5",""), linkmap),
         "quiz": parse_quiz(sec.get("6",""), linkmap),
         "pub": "🌍" in fm.get("exposicion","🌍"),
         "ref": fm.get("fuente_canonica","")}
    vp, vf = fm.get("verificado_por",""), fm.get("verificado_fecha","")
    if vp: o["ver"] = f"{vp} · {vf}"
    js = json.dumps(o, ensure_ascii=False)
    out.append(f"P.{nid}=Object.assign(P.{nid}||{{}},{js});")
    print(f"✅ {nid:15s} ← {os.path.basename(f)}  (n1 {len(o['n1'])}c · n2 {len(o['n2'])}c · n3 {len(o['n3'])}c · {len(o['casos'])} casos · {len(o['quiz'])} quiz)")

stamp = datetime.date.today().isoformat()
block = f"/*__PG_BUILD_START__*/\n/* generado {stamp} · {len(out)} páginas desde Pages/ — NO editar a mano */\n" + "\n".join(out) + "\n/*__PG_BUILD_END__*/"
hub = open(HUB,encoding="utf-8").read()
new, n = re.subn(r'/\*__PG_BUILD_START__\*/.*?/\*__PG_BUILD_END__\*/', lambda _ : block, hub, count=1, flags=re.S)
assert n==1, "marcadores __PG_BUILD__ no encontrados en el hub"
new = re.sub(r'data-updated="[0-9-]+"', f'data-updated="{stamp}"', new, count=1)
open(HUB,"w",encoding="utf-8").write(new)
print(f"\n🏁 Hub actualizado: {len(out)} páginas construidas · data-updated={stamp}")
```

---

## El script del BUILD PÚBLICO (v01 · 2026-07-22 · antídoto #5)

Genera `MatriX-Hub-Publico-v01.html` a partir del hub interno ya construido. Correr **después** del build normal. Uso: copiar a `/tmp/mtxbuild_publico.py` y `python3 /tmp/mtxbuild_publico.py <ruta a IB-MTX-MatriX>`. La verificación integrada aborta con exit 1 si detecta fugas.

```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Build público de MatriX: MatriX-Hub-v01.html -> MatriX-Hub-Publico-v01.html
Antídoto #5 del MasterPlan: el build público EXCLUYE FÍSICAMENTE el nivel N3
y las páginas 🔒 internas (no las oculta con CSS/JS)."""
import re, os, sys, json, datetime

BASE = sys.argv[1] if len(sys.argv)>1 else "."
SRC = os.path.join(BASE, "MatriX-Hub-v01.html")
DST = os.path.join(BASE, "MatriX-Hub-Publico-v01.html")
html = open(SRC, encoding="utf-8").read()

# ── 1. Bloque build: eliminar entradas pub:false, vaciar n3 en el resto ──
m = re.search(r'/\*__PG_BUILD_START__\*/(.*?)/\*__PG_BUILD_END__\*/', html, re.S)
assert m, "marcadores __PG_BUILD__ no encontrados"
block = m.group(0)
internal, kept = set(), []
for line in m.group(1).splitlines():
    mm = re.match(r'P\.(\w+)=Object\.assign\(P\.\w+\|\|\{\},(\{.*\})\);$', line)
    if not mm:
        kept.append(line); continue
    pid = mm.group(1)
    o = json.loads(mm.group(2))
    if not o.get("pub", False):
        internal.add(pid); continue
    o["n3"] = ""  # exclusión física del nivel Ingeniería
    kept.append("P."+pid+"=Object.assign(P."+pid+"||{},"+json.dumps(o, ensure_ascii=False)+");")
stamp = datetime.date.today().isoformat()
newblock = ("/*__PG_BUILD_START__*/\n/* BUILD PUBLICO generado "+stamp+" · "
    +str(len([k for k in kept if k.startswith('P.')]))+" páginas públicas · N3 y páginas internas EXCLUIDAS físicamente */\n"
    +"\n".join([k for k in kept if k.startswith('P.')])+"\n/*__PG_BUILD_END__*/")
html = html.replace(block, newblock)
print("internas excluidas ("+str(len(internal))+"):", ", ".join(sorted(internal)))

# ── 2. Eliminar llamadas estáticas S()/W() de ids internos ──
for pid in sorted(internal):
    html, n = re.subn(r'\n[SW]\("'+pid+r'",.*?\);\n', '\n', html, count=1, flags=re.S)
    if n: print("  estática removida:", pid)

# ── 3. Vaciar n3 inline en páginas modelo estáticas ──
html, n = re.subn(r"\n n3:'.*?',\n casos:", "\n n3:'',\n casos:", html, flags=re.S)
print("n3 estáticos vaciados:", n)

# ── 4. DOMS: quitar d8 e ids internos de los items ──
html = re.sub(r'\n \{id:"d8".*?\},?\n', '\n', html, flags=re.S)
def filtra(mo):
    ids = re.findall(r'"(\w+)"', mo.group(1))
    return 'items:['+",".join('"'+i+'"' for i in ids if i not in internal)+']'
html = re.sub(r'items:\[([^\]]*)\]', filtra, html)

# ── 5. Forzar modo público: CLIENTE fijo, sin botón 🔬 ni toggle ──
html = html.replace('CLIENTE=localStorage.getItem("mtx-cliente")==="1";', 'CLIENTE=true; /* build público: fijo */')
html = html.replace('    <button data-lvl="3">🔬 Ingeniería</button>\n', '')
html = html.replace('id="clienteBtn"', 'id="clienteBtn" style="display:none"')
html = html.replace('function setCliente(on){CLIENTE=on;', 'function setCliente(on){CLIENTE=true;on=true;')
# Rutas internas del vault fuera del artefacto público
html = re.sub(r'var GRAFO="[^"]*";', 'var GRAFO="#";', html)
html = re.sub(r'var WIKIX="[^"]*";', 'var WIKIX="#";', html)
# Branding
html = html.replace('Playbook multidimensional · v01 prototipo', 'Playbook del ecosistema WORX · versión pública')
html = re.sub(r'data-updated="[0-9-]+"', 'data-updated="'+stamp+'" data-build="publico"', html, count=1)

open(DST, "w", encoding="utf-8").write(html)

# ── 6. Verificación: cero contenido interno ──
pub = open(DST, encoding="utf-8").read()
leaks = []
for pid in internal:
    if re.search(r'P\.'+pid+r'\s*=', pub): leaks.append("P."+pid+" sigue definida")
if re.search(r'"n3": "[^"]', pub): leaks.append("n3 con contenido en el bloque build")
if leaks:
    print("❌ FUGAS:", leaks); sys.exit(1)
print("✅ verificación PASS: 0 páginas internas · 0 n3 con contenido en build")
print("🏁 " + DST)
```

**Nota editorial pendiente (no bloqueante):** el N2 de dos páginas públicas (`hiorg` 2.1 y `sooi` 1.4) menciona el modelo de cubos (incl. "Cubo C se queda en la fábrica"). N2 es nivel clientes por diseño, pero la frontera exacta de qué detalle comercial va en N2 público es decisión editorial de Victor — revisar antes del go-live público.

## CHANGELOG

| Versión | Fecha | Cambio |
|---|---|---|
| v01 | 2026-07-16 | Creación (Jay). Script del build Pages/ → Hub, regla de fuente única. |
| v01 (rev. 22-jul) | 2026-07-22 | JC: (1) MAPID actualizado — 1.1 `paraguas`, 7.6 `r100x`, +0.3/0.4/0.5 (`rutaimpl`/`rutaing`/`vistarol`); (2) filtro de `PilaWORX` obsoleta; (3) regla 5 (plantilla obligatoria — lección del caso D8 en blanco); (4) regla 6 + **script del build público** (antídoto #5) con verificación anti-fugas integrada. |

---

*SOP-MTX-MatriX-BuildPagesHub-v01 · Owner: Victor · Sherpa: Jay · Ratifica: Victor · 2026-07-16 · rev. 2026-07-22*