Esta edición está destinada a lectura. No se ofrece un archivo de descarga del documento desde esta página.
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
COMPENDIO ACADÉMICO
PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES
VOLUMEN III
Código Operacional Completo · Los Cuatro Patrones · Python 3.8+ · Sin Dependencias
Externas
Giovany Guarín Ramírez · C.C. 1.036.392.210 · T.P. 184954
La Ceja del Tambo, Antioquia, Colombia · 2026
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
10. PRESENTACIÓN DEL CÓDIGO OPERACIONAL
Este volumen presenta el código fuente operacional que implementa cada uno de los cuatro
patrones metodológicos documentados en los volúmenes I y II. El código es Python 3.8+ sin
dependencias externas, extraído y documentado desde mens_scca_v1_0.py (2219 líneas,
33/33 tests unitarios aprobados, registrado ante la DNDA — Dirección Nacional de Derechos
de Autor de Colombia).
Para cada patrón se presenta: (a) el fragmento de código que formula y operacionaliza el
patrón, (b) la documentación técnica de cada componente, (c) el contrato de la función
(precondiciones, postcondiciones, casos edge cubiertos), y (d) la integración con los demás
patrones.
Patrón Clases/Funciones principales Líneas de Sección
código core
P1 — MotorFCBRIC, PayloadBlindado, ~180 §11
Sellado _cifrar_campos_sensibles(),
en _generar_sello_tsa(), blindar()
Origen
P2 — MotorMCO._presencia(), ~30 §12
Centinel MotorMCO._sustantivo()
a
Ternario
P3 — ServicioTraductor, ~120 §13
Fan-out TraductorPerfiles,
Pondera CAMPOS_POR_PERFIL,
do PESO_PERFIL,
_analizar_comunicacional()
P4 — MotorMCG, ~90 §14
Madurez MotorMCO._analizar_estrategico(
Acreditat ), CONDICIONES_NIVEL,
iva _nivel_alcanzado()
Tabla 10.1 — Mapa de código por patrón: clases, funciones y sección de este volumen
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
11. CÓDIGO — PATRÓN 1: SELLADO EN ORIGEN
[ P1 · MotorFCBRIC · PayloadBlindado · mens_scca_v1_0.py ]
11.1 Estructura de datos: PayloadBlindado
El dataclass PayloadBlindado es la unidad atómica de evidencia. Su diseño garantiza que no
puede instanciarse sin los campos de sellado — el dato nace ya dentro del perímetro
criptográfico.
● PayloadBlindado — dataclass
# ═══════════════════════════════════════════════════════════════════════
# PATRÓN 1 — SELLADO EN ORIGEN (Origin-Sealed Evidence)
# Extracto de mens_scca_v1_0.py — © 2026 Guarín Ramírez
# ═══════════════════════════════════════════════════════════════════════
# ── ESTRUCTURA DE DATOS ──────────────────────────────────────────────
@dataclass
class PayloadBlindado:
"""
Unidad atómica de evidencia: dato + sello criptográfico.
No puede existir sin su sello — nace ya dentro del perímetro.
"""
payload_id: str # UUID v4 — unicidad universal
contenido_hash: str # SHA-256 del payload protegido
firma_hmac: str # HMAC-SHA256 con clave institucional
sello_tsa: str # RFC 3161 (Certicámara CO / FreeTSA)
jurisdiccion: str = "CO" # Portabilidad LATAM [C4]
tsa_endpoint: str = "" # URL TSA usada
cadena_custodia: List[Dict] = field(default_factory=list)
timestamp: str = field(
default_factory=lambda: datetime.now().isoformat()
)
Código 11.1 — PayloadBlindado: estructura de datos del dato sellado en origen
11.2 Capa 4: cifrado de campos sensibles
● _cifrar_campos_sensibles() — PBKDF2-XOR-SHA256
# ── CAPA 4: CIFRADO DE CAMPOS SENSIBLES (PBKDF2-XOR-SHA256) ─────────
def _cifrar_campos_sensibles(self, payload: dict) -> dict:
"""
[O1][C2] Cifra campos con datos personales sensibles.
Algoritmo: XOR sobre keystream PBKDF2-HMAC-SHA256.
100.000 iteraciones, salt aleatorio de 16 bytes por instancia.
Cumplimiento Ley 1581/2012 — principio de confidencialidad.
Campos protegidos: participante, scores_emf, diagnostico.
"""
campos_sensibles = ["participante", "scores_emf", "diagnostico"]
payload_cifrado = dict(payload)
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
for campo in campos_sensibles:
if payload_cifrado.get(campo):
dato = json.dumps(
payload_cifrado[campo], ensure_ascii=False
).encode("utf-8")
# XOR sobre keystream derivado con PBKDF2
ct = bytes(
b ^ self._keystream[i % len(self._keystream)]
for i, b in enumerate(dato)
)
payload_cifrado[campo] = (
"ENC_MENS_SCCA_PBKDF2XOR:" +
base64.b64encode(ct).decode("ascii")
)
# Metadatos de cifrado para trazabilidad
payload_cifrado["_cifrado_algoritmo"] = "PBKDF2-XOR-SHA256"
payload_cifrado["_salt_b64"] = base64.b64encode(
self._salt_cifrado
).decode("ascii")
payload_cifrado["_ley_1581"] = "cumplimiento"
payload_cifrado["_mens_version"] = _MENS_SCCA_VERSION
return payload_cifrado
Código 11.2 — Cifrado de campos sensibles con PBKDF2-XOR-SHA256
11.3 Capa 3: sello RFC 3161
La función _generar_sello_tsa() implementa el principio de degradación honesta: intenta
Certicámara, hace fallback a FreeTSA, y si no hay conectividad genera un sello local
explícitamente marcado como NO_ACREDITABLE. El sistema nunca simula tener capacidades
que no tiene.
● _generar_sello_tsa() — RFC 3161 + fallback honesto
# ── CAPA 3: SELLO RFC 3161 ────────────────────────────────────────────
def _generar_sello_tsa(self, hash_val: str) -> str:
"""
[C1] Genera sello RFC 3161 via Certicámara Colombia (primario).
Fallback 1: FreeTSA (internacional).
Fallback 2: sello local marcado NO_ACREDITABLE_ANTE_TERCERO.
El sistema nunca miente sobre el tipo de sello generado.
"""
hash_bytes = bytes.fromhex(hash_val)
nonce = int.from_bytes(os.urandom(8), "big")
tsq = self._construir_tsq(hash_bytes, nonce) # DER manual
for url in [self._tsa_activo, self.TSA_URL_BACKUP]:
try:
req = urllib.request.Request(
url=url, data=tsq,
headers={"Content-Type": "application/timestamp-query"},
)
with urllib.request.urlopen(req, timeout=10) as resp:
tsr_bytes = resp.read()
if not self._verificar_tsr(tsr_bytes):
continue
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
token_b64 = base64.b64encode(tsr_bytes).decode("ascii")
endpoint_tag = (
"CERTICAMARA" if "certicamara" in url else "FREETSA"
)
return f"RFC3161:REAL:{endpoint_tag}:{token_b64}"
except (urllib.error.URLError, Exception):
continue
# Fallback local — explícitamente no acreditable
return self._sello_local(
hash_val,
razon="Sin conectividad a TSA primaria (Certicámara) ni respaldo"
)
def _sello_local(self, hash_val: str, razon: str = "modo local") -> str:
timestamp = datetime.now().isoformat()
return (
f"RFC3161:LOCAL:"
f"ts={timestamp}:hash={hash_val[:32]}:"
f"advertencia=NO_ACREDITABLE_ANTE_TERCERO:razon={razon}"
)
Código 11.3 — Sello RFC 3161 con degradación honesta
11.4 Función principal: blindar()
● blindar() — operación atómica de sellado
# ── FUNCIÓN PRINCIPAL: blindar() ─────────────────────────────────────
def blindar(self, payload: dict, evento_inicial: str = "CREACION")
-> PayloadBlindado:
"""
Operación atómica — las 4 capas en secuencia obligatoria.
El dato NO puede existir sin su sello.
"""
# CAPA 4: cifrado de campos sensibles
payload_protegido = self._cifrar_campos_sensibles(payload)
# CAPA 1: huella SHA-256
hash_val = self._calcular_hash(payload_protegido)
# CAPA 2: firma HMAC-SHA256
firma = self._firmar_hmac(payload_protegido)
# CAPA 3: sello RFC 3161
sello = self._generar_sello_tsa(hash_val)
# Ensamblaje del PayloadBlindado
blindado = PayloadBlindado(
payload_id=str(uuid.uuid4()),
contenido_hash=hash_val,
firma_hmac=firma,
sello_tsa=sello,
jurisdiccion=self.jurisdiccion,
tsa_endpoint=self._tsa_activo,
)
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
# Registro en cadena de custodia
blindado.cadena_custodia.append({
"evento": evento_inicial,
"timestamp": blindado.timestamp,
"hash_estado": hash_val,
"cifrado": True,
"algoritmo": "PBKDF2-XOR-SHA256",
"ley_1581": "cumplimiento",
"jurisdiccion": self.jurisdiccion,
"tsa_endpoint": self._tsa_activo,
"mens_version": _MENS_SCCA_VERSION,
})
return blindado
# ── USO ───────────────────────────────────────────────────────────────
motor = MotorFCBRIC(
clave_institucional="clave_segura_institucional",
usar_tsa_real=True,
jurisdiccion="CO", # Colombia — Certicámara
)
blindado = motor.blindar(payload, evento_inicial="SESION_CLINICA")
# blindado.sello_tsa comienza con "RFC3161:REAL:CERTICAMARA:"
# si hay conectividad, o "RFC3161:LOCAL:" con advertencia si no.
Código 11.4 — Función blindar(): operación atómica que compone las 4 capas
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
12. CÓDIGO — PATRÓN 2: CENTINELA TERNARIO
[ P2 · MotorMCO._presencia() · MotorMCO._sustantivo() · mens_scca_v1_0.py ]
12.1 Implementación completa del centinela
El centinela ternario está implementado en 18 líneas de código con cobertura total de casos
edge. La implementación es estática para garantizar que puede usarse sin instanciar
MotorMCO — permite composición con cualquier sistema que opere sobre diccionarios Python.
● _presencia() + _sustantivo() — centinela ternario completo
# ═══════════════════════════════════════════════════════════════════════
# PATRÓN 2 — CENTINELA TERNARIO DE PRESENCIA
# Extracto de mens_scca_v1_0.py — © 2026 Guarín Ramírez
# ═══════════════════════════════════════════════════════════════════════
# ── CONSTANTES DE ESTADO ─────────────────────────────────────────────
class MotorMCO:
AUSENTE = "AUSENTE" # campo no está en el dict
VACIO = "VACÍO" # campo está pero sin contenido sustantivo
PRESENTE = "PRESENTE" # campo está y tiene contenido sustantivo
@staticmethod
def _presencia(datos: dict, campo: str) -> str:
"""
[O9] Centinela ternario — implementación completa.
Precondición: datos es un dict válido.
Postcondición: retorna exactamente uno de {AUSENTE, VACÍO, PRESENTE}.
Casos edge cubiertos:
- campo not in datos → AUSENTE
- campo in datos, valor=None → VACÍO
- campo in datos, valor="" → VACÍO
- campo in datos, valor=[] → VACÍO
- campo in datos, valor={} → VACÍO
- campo in datos, valor=set() → VACÍO
- campo in datos, valor=False → PRESENTE (excepción crítica)
- campo in datos, valor=0 → PRESENTE (excepción crítica)
- campo in datos, valor=<cualquier otro> → PRESENTE
"""
# PASO 1: ¿el campo existe en el dict?
if campo not in datos:
return MotorMCO.AUSENTE
valor = datos[campo]
# PASO 2: EXCEPCIÓN CRÍTICA
# False y 0 son valores sustantivos válidos en dominios clínicos.
# semaforo=0, nivel=False, inhibicion=0 son estados reales.
# Sin esta excepción, Python los trataría como "falsy" = vacíos.
if valor is False or valor == 0:
return MotorMCO.PRESENTE
# PASO 3: contenedores vacíos y None → VACÍO
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
if valor is None:
return MotorMCO.VACIO
if isinstance(valor, (str, list, dict, set)) and len(valor) == 0:
return MotorMCO.VACIO
# PASO 4: cualquier otro valor sustantivo
return MotorMCO.PRESENTE
@staticmethod
def _sustantivo(datos: dict, campo: str) -> bool:
"""
Atajo semántico: True solo si el campo está PRESENTE.
Usado en condiciones de avance y verificación de cobertura.
"""
return MotorMCO._presencia(datos, campo) == MotorMCO.PRESENTE
# ── USO COMO INVARIANTE TRANSVERSAL ──────────────────────────────────
# En todos los ejes del MCO:
# Eje SISTÉMICO — clasificación antes de cualquier acceso
p_scores = self._presencia(datos, "scores_emf")
if p_scores == self.AUSENTE:
hallazgos.append("scores_emf AUSENTE — campo no enviado")
elif p_scores == self.VACIO:
hallazgos.append("scores_emf VACÍO — evaluación sin scores")
else:
scores_emf = datos["scores_emf"] # acceso seguro
# Eje ESTRATÉGICO — condiciones de nivel MCG
# instrumentos_operativos=[] → VACÍO → _sustantivo retorna False
# → nivel bloqueado en N-1 (correcto)
# valoracion_mercantil=False → PRESENTE → _sustantivo retorna True
# → nivel avanza (correcto)
if not all(self._sustantivo(datos, c) for c in condiciones):
return nivel - 1 # progresión bloqueada
Código 12.1 — Implementación completa del Centinela Ternario con uso como invariante transversal
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
13. CÓDIGO — PATRÓN 3: FAN-OUT CON FIDELIDAD
PONDERADA
[ P3 · ServicioTraductor · CAMPOS_POR_PERFIL · PESO_PERFIL · mens_scca_v1_0.py ]
13.1 Contratos de fidelidad
● CAMPOS_POR_PERFIL + PESO_PERFIL — contratos de fidelidad
# ═══════════════════════════════════════════════════════════════════════
# PATRÓN 3 — FAN-OUT CON FIDELIDAD PONDERADA
# Extracto de mens_scca_v1_0.py — © 2026 Guarín Ramírez
# ═══════════════════════════════════════════════════════════════════════
# ── CONTRATOS DE FIDELIDAD POR PERFIL ────────────────────────────────
# Estructura: {campo: peso}
# peso 1.0 = crítico para admisibilidad del perfil
# peso 0.5 = relevante pero regenerable o secundario
CAMPOS_POR_PERFIL: Dict[str, Dict[str, float]] = {
"nino": {"logros": 1.0, "semaforo": 0.5},
"docente": {"ajustes": 1.0, "alertas": 1.0, "curvas": 0.5},
"terapeuta": {"scores_emf": 1.0, "alertas": 1.0, "tendencias": 0.5},
"familia": {"semaforo": 1.0, "ajustes": 0.5, "sugerencias": 0.5},
"juez": {"blindado": 1.0, "normativa": 1.0,
"cadena_custodia": 1.0},
"investigador": {"scores_emf": 1.0, "normativa": 0.5},
}
# Peso relativo de cada perfil en la fidelidad global ponderada
# Refleja impacto probatorio del perfil en el ecosistema MENS
PESO_PERFIL: Dict[str, float] = {
"juez": 1.0, # máximo — evidencia ante instancia judicial
"terapeuta": 0.9, # alto — decisión clínica directa
"investigador": 0.7, # medio-alto — validez metodológica
"docente": 0.6, # medio — impacto pedagógico
"familia": 0.5, # medio-bajo — comunicación de apoyo
"nino": 0.4, # mínimo — comunicación motivacional
}
Código 13.1 — Contratos de fidelidad: campos por perfil y pesos de importancia probatoria
13.2 Cálculo de fidelidad y fan-out reactivo
● _analizar_comunicacional() — cálculo de fidelidad ponderada
# ── CÁLCULO DE FIDELIDAD POR PERFIL ─────────────────────────────────
def _analizar_comunicacional(self, datos: Any) -> ResultadoAnalisisMCO:
"""
Calcula fidelidad por perfil usando el Centinela Ternario (P2).
Emite alertas diferenciadas según el peso del perfil en riesgo.
"""
fidelidad_por_perfil: Dict[str, float] = {}
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
perfiles_en_riesgo: List[str] = []
for perfil, campos in self.CAMPOS_POR_PERFIL.items():
peso_total = sum(campos.values())
peso_cubierto = 0.0
ausentes: List[str] = []
for campo, peso in campos.items():
# Usa Centinela Ternario (P2):
# PRESENTE cubre 0 y False como valores válidos.
# VACÍO y AUSENTE = campo no cubierto para este perfil.
estado = self._presencia(datos, campo)
if estado == self.PRESENTE:
peso_cubierto += peso
else:
etiqueta = "VACÍO" if estado == self.VACIO else "AUSENTE"
ausentes.append(f"{campo}[{etiqueta}](w={peso})")
fidelidad = round(peso_cubierto / peso_total, 3)
fidelidad_por_perfil[perfil] = fidelidad
if fidelidad < 1.0:
perfiles_en_riesgo.append(perfil)
# Fidelidad global ponderada por importancia del perfil
peso_total_perfiles = sum(self.PESO_PERFIL.values())
fidelidad_global = round(
sum(
fidelidad_por_perfil[p] * self.PESO_PERFIL.get(p, 0.5)
for p in fidelidad_por_perfil
) / peso_total_perfiles, 3
)
# Alertas diferenciadas por impacto del perfil
if "juez" in perfiles_en_riesgo:
hallazgos.append(
"ALERTA PROBATORIA: Perfil JUEZ con fidelidad incompleta"
" — evidencia no admisible sin campos primarios."
)
if "terapeuta" in perfiles_en_riesgo:
hallazgos.append(
"ALERTA CLÍNICA: Perfil TERAPEUTA con fidelidad incompleta"
" — decisión clínica comprometida."
)
Código 13.2 — Cálculo de fidelidad ponderada con alertas diferenciadas
13.3 Fan-out reactivo y anonimización por diseño
● ServicioTraductor.traducir_para_todos() — fan-out de 6 perfiles
# ── SERVICIO DE TRADUCCIÓN — FAN-OUT REACTIVO ────────────────────────
class ServicioTraductor(SistemaMENSSCCA):
"""
[O2] Cache indexado por (participante, timestamp).
Elimina cruce de datos bajo carga concurrente.
"""
def __init__(self, bus: BusMens):
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
super().__init__(bus, "Traductor")
self.traductor = TraductorPerfiles()
self._cache_payloads: Dict[str, dict] = {}
self._lock_cache = threading.Lock()
# Suscripciones al bus
bus.suscribir("reporte_piar_generado", self._cachear_payload)
bus.suscribir("payload_blindado", self.traducir_para_todos)
def traducir_para_todos(self, blindado: dict) -> None:
# Recuperar payload clínico por timestamp de cadena de custodia
cadena = blindado.get("cadena_custodia", [])
ts_blindado = cadena[0].get("timestamp", "") if cadena else ""
with self._lock_cache:
payload_clinico = next(
(v for k, v in self._cache_payloads.items()
if ts_blindado and ts_blindado in k), None
) or (list(self._cache_payloads.values())[-1]
if self._cache_payloads else {})
# Enriquecimiento: semáforo, alertas, tendencias, sugerencias
payload_enriquecido = dict(payload_clinico)
payload_enriquecido["blindado"] = blindado
# ... (lógica de semáforo y tendencias)
# FAN-OUT: 6 traducciones simultáneas
traducciones = {
perfil.value: self.traductor.traducir(payload_enriquecido, perfil)
for perfil in PerfilUsuario
}
self.bus.publicar("traducciones_completadas", {
"payload_id": blindado.get("payload_id", ""),
"traducciones": traducciones,
"timestamp": datetime.now().isoformat(),
})
# ── TRADUCTOR POR PERFIL — ANONIMIZACIÓN POR DISEÑO ─────────────────
class TraductorPerfiles:
@staticmethod
def traducir(payload: dict, perfil: PerfilUsuario) -> dict:
if perfil == PerfilUsuario.INVESTIGADOR:
# Privacy by design: excluye identificadores automáticamente
return {k: v for k, v in payload.items()
if k not in ["identificacion", "nombre"]}
elif perfil == PerfilUsuario.JUEZ:
return {
"evidencia": payload.get("blindado", {}),
"fundamento_normativo": payload.get("normativa", []),
"trazabilidad": payload.get("cadena_custodia", []),
"jurisdiccion": payload.get("jurisdiccion", "CO"),
}
# ... (otros perfiles)
Código 13.3 — Fan-out reactivo: 6 traducciones simultáneas con anonimización en perfil INVESTIGADOR
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
14. CÓDIGO — PATRÓN 4: MADUREZ DE
ACREDITABILIDAD
[ P4 · MotorMCG · CONDICIONES_NIVEL · _nivel_alcanzado() · mens_scca_v1_0.py ]
14.1 Tabla de condiciones y algoritmo de nivel
● CONDICIONES_NIVEL + _nivel_alcanzado() + _analizar_estrategico()
# ═══════════════════════════════════════════════════════════════════════
# PATRÓN 4 — MADUREZ DE ACREDITABILIDAD DE EVIDENCIA
# Extracto de mens_scca_v1_0.py — © 2026 Guarín Ramírez
# ═══════════════════════════════════════════════════════════════════════
# ── CONDICIONES POR NIVEL — TABLA DE VERDAD ──────────────────────────
CONDICIONES_NIVEL: Dict[int, Dict[str, str]] = {
1: {
"scores_emf": "Evaluación de funciones ejecutivas documentada",
"ajustes": "Ajustes razonables definidos",
"normativa": "Respaldo normativo identificado",
},
2: {
"blindado": "Payload con blindaje criptográfico FC-BRIC v2",
"participante": "Participante identificado en el payload",
},
3: {
"valoracion_mercantil":
"Valoración mercantil o institucional documentada",
},
4: {
"blindaje_legal":
"Blindaje legal completado",
"instrumentos_operativos":
"Instrumentos operativos activos",
},
# Nivel 5: no tiene condiciones adicionales.
# Se alcanza cuando el nivel 4 está completo.
# acreditable = True por definición en nivel 5.
}
# ── ALGORITMO DE NIVEL — PROGRESIÓN ESTRICTAMENTE ACUMULATIVA ────────
def _nivel_alcanzado(self, datos: dict) -> int:
"""
[O8][O9] Calcula el nivel MCG alcanzado.
Propiedad acumulativa: el nivel N se alcanza SOLO si
todas las condiciones de los niveles 1..N están presentes.
Usa _sustantivo() (Centinela Ternario P2):
- instrumentos_operativos=[] → VACÍO → no cuenta como PRESENTE
→ nivel bloqueado en N-1 (correcto)
- valoracion_mercantil=False → PRESENTE → avanza
(False es valor sustantivo válido)
"""
for nivel in range(1, 6):
condiciones = self.CONDICIONES_NIVEL.get(nivel, {})
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
if condiciones and not all(
self._sustantivo(datos, c) for c in condiciones
):
return nivel - 1
return 5
# ── DIAGNÓSTICO DE BLOQUEANTES ────────────────────────────────────────
def _analizar_estrategico(self, datos: Any) -> ResultadoAnalisisMCO:
nivel_alcanzado = self._nivel_alcanzado(datos)
nivel_objetivo = min(nivel_alcanzado + 1, 5)
condiciones_bloqueantes: List[str] = []
condiciones_cumplidas: List[str] = []
if nivel_alcanzado < 5:
for campo, descripcion in condiciones_objetivo.items():
if self._sustantivo(datos, campo):
condiciones_cumplidas.append(descripcion)
else:
# Usa Centinela Ternario para precisión en el diagnóstico
estado = self._presencia(datos, campo)
sufijo = ("(campo vacío)" if estado == self.VACIO
else "(campo ausente)")
condiciones_bloqueantes.append(
f"BLOQUEANTE para NIVEL{nivel_objetivo}: "
f"{descripcion} — {sufijo}."
)
# Nivel 5 es acreditable por definición
acreditable = (nivel_alcanzado == 5) or (
nivel_alcanzado < 5 and len(condiciones_bloqueantes) == 0
)
Código 14.1 — Tabla de condiciones, algoritmo de progresión acumulativa y diagnóstico de bloqueantes
14.2 Motor MCG e integración completa
El fragmento siguiente muestra la integración de los cuatro patrones en el flujo completo del
sistema. Un solo evento "solicitar_reporte_piar" activa la cadena completa: P2 clasifica los
campos, P1 sella, P4 evalúa el nivel, P3 genera las 6 salidas diferenciadas.
● MotorMCG + integración P1+P2+P3+P4
# ── MOTOR MCG — EVALUACIÓN DE MADUREZ INSTITUCIONAL ─────────────────
class MotorMCG:
"""
Vector de coherencia:
"Cada fase produce el insumo sin el cual la siguiente
no puede reclamar credibilidad ante un tercero exigente."
"""
def evaluar(self, sistema: SistemaRegistrado,
metadata: Dict) -> EvaluacionMCG:
# [O3] Secuencia estrictamente acumulativa
nivel = NivelMCG.NIVEL1_DIAGNOSTICO
if "validacion_externa" in metadata:
nivel = NivelMCG.NIVEL2_VIABILIDAD
if nivel.value >= 2 and "valoracion_mercantil" in metadata:
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
nivel = NivelMCG.NIVEL3_VALORACION
if nivel.value >= 3 and "blindaje_legal" in metadata:
nivel = NivelMCG.NIVEL4_PROTECCION
if nivel.value >= 4 and "instrumentos_operativos" in metadata:
nivel = NivelMCG.NIVEL5_INSTRUMENTACION
siguiente = (
f"Avanzar a {NivelMCG(nivel.value + 1).name}"
if nivel.value < 5 else "Sistema maduro"
)
return EvaluacionMCG(
sistema_id=sistema.id,
nivel_actual=nivel,
progreso={...},
vector_coherencia=self.vector_coherencia,
siguiente_paso=siguiente,
)
# ── INTEGRACIÓN COMPLETA — DEMO DEL SISTEMA ──────────────────────────
# Los 4 patrones operando en secuencia:
bus = BusMens() # tálamo — pub/sub con prioridad
registro = RegistroSistemas() # registro de sistemas
memoria = MemoriaLargoPlazo(bus) # hipocampo SQLite WAL
# P2 opera dentro de MotorMCO (6 ejes)
mco = ServicioMCO(bus, MotorMCO(registro=registro))
# P4 opera dentro de MotorMCG
mcg = ServicioMCG(bus, MotorMCG(), registro)
# P1 opera dentro de MotorFCBRIC
motor_fcbric = MotorFCBRIC("clave", usar_tsa_real=True, jurisdiccion="CO")
fcbric = ServicioFCBRIC(bus, motor_fcbric)
# P3 opera dentro de ServicioTraductor
traductor = ServicioTraductor(bus)
# Disparar flujo — los 4 patrones se activan en secuencia
bus.publicar("solicitar_reporte_piar", {"participante": "P001"})
bus.esperar_cola() # bloquea hasta procesamiento completo
# Resultado: evidencia acreditable, semánticamente correcta,
# con nivel MCG calculado, y 6 perfiles diferenciados.
Código 14.2 — Motor MCG con integración completa de los cuatro patrones
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
15. SÍNTESIS TÉCNICA Y POTENCIAL DE
GENERALIZACIÓN
15.1 Los cuatro patrones — síntesis técnica
Patrón Problema resuelto Extensión original API mínima
P1 Dato acreditable desde TEE de hardware → motor.blindar(payload)
t=0 sin intervalo de Python puro + RFC
impugnación 3161
P2 Ambigüedad semántica Null Object binario → _presencia(datos,
AUSENTE vs. VACÍO en centinela ternario con campo)
cualquier dominio excepción falsy
P3 Adaptación manual de Fan-out uniforme → bus.publicar("evento",
salidas para audiencias contratos de fidelidad payload)
heterogéneas ponderada por
receptor
P4 Calidad del sistema CMMI de _nivel_alcanzado(datos)
productora de evidencia organizaciones →
opaca madurez de
instancias de dato
Tabla 15.1 — Síntesis técnica de los cuatro patrones con API mínima de cada uno
15.2 Potencial de generalización
El denominador común de los cuatro patrones es que resuelven el problema de la
acreditabilidad diferenciada de datos — la necesidad de que un dato sea confiable, verificable y
comunicable para múltiples receptores con distintos niveles de exigencia. Este problema
aparece en cualquier dominio donde el dato tiene consecuencias más allá de la transacción
que lo generó.
La generalización no requiere reinventar los patrones. Requiere: (1) identificar el objeto de
evaluación en el dominio destino, (2) definir los contratos de fidelidad para los receptores del
dominio, (3) adaptar las condiciones de nivel a los estándares de calidad del dominio, y (4)
conectar el sellado a la TSA o PKI relevante para la jurisdicción.
MENS·SCCA v1.0 — DECLARACIÓN TÉCNICA FINAL
Los cuatro patrones implementados en MENS·SCCA v1.0 constituyen extensiones
originales de patrones establecidos, verificables en el código fuente registrado ante la
DNDA (2219 líneas, 33/33 tests unitarios). Su composición produce la primera
arquitectura de software clínico conocida que integra acreditabilidad jurídica nativa,
semántica ternaria de presencia, traducción reactiva multi-receptor con fidelidad
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993
COMPENDIO ACADÉMICO · PATRONES ESTRUCTURALES EN SISTEMAS DIGITALES | Volumen III — Código Operacional
ponderada, y madurez de acreditabilidad de evidencia como propiedades emergentes de
un flujo de trabajo clínico normal.
La adopción de estos patrones en sistemas digitales de cualquier dominio donde los
datos tienen consecuencias probatorias, regulatorias o científicas produce beneficios
verificables sin costo incremental de operación para el usuario final.
© 2026 — Guarín Ramírez · MENS·SCCA v1.0 · Ley 23/1982 · Decisión Andina 351/1993