CÁPSULA CERTIFICADA • ENTREGA INMEDIATA CRC-02 // EJECUTOR DE POLÍTICAS AST ACI 1.0000 • IDL 91.25

$290 USD 24H SLA INVIOLABLE • <= 3.0 ms (Recorrido AST Estático)

V1_AGENT_SECURITY • COMPUERTA ZERO-TRUST AEGIS

Claude Rules Compiler: Convierte Reglas de `CLAUDE.md` en Bloqueos AST Deterministas

Linaje Científico (SIG-1d0a63f087edb904): Cuando 'No Hacer' No Es Bloquear: Compilación de Reglas en CLAUDE.md hacia Controles AST Duros

Ecuación Rectora de la Compuerta Determinista: Enforce(R_md, AST_patch) = BLOCKED if exists r in Compile(R_md): Match(r, AST_patch)

SUITE PYTEST

7 APROBADOS / 0 FALLOS

COBERTURA / ARCHIVOS

100% • 5 ARCHIVOS

ORÁCULO LOCAL-QWEN

100.0% APROBADO

ORÁCULO CLAUDE-FRONTIER

100.0% APROBADO

1. Dolor Real del Sector (DANTE)

Entre el 84% y el 95.6% de las reglas escritas en `CLAUDE.md` o `.cursorrules` ('no tocar la base de producción', 'nunca subir secretos') dependen de la buena voluntad del modelo y son ignoradas bajo presión.

2. Por qué fallan las alternativas

Las instrucciones en Markdown son buenos deseos si no existe un compilador AST que bloquee rutas, imports y comandos prohibidos antes de ejecutarse.

3. Resultado Garantizado

Compila cada cláusula 'nunca / prohibido' en bloqueos duros (`PATH_DENY`, `COMMAND_DENY`, `IMPORT_DENY`) y reporta cualquier regla ambigua.

EJECUCIÓN REAL EN TERMINAL: SARA GATE (0.38 MS) • AST PRUNER (-66.1%) • M2M VAULT

CTXFW v4.1.1 Live Terminal Demo — SARA Prompt Injection Gate (0.38ms), AST Context Pruner (-66.1%) & M2M Sovereign Vault

Stack: Python 3.10+, Pydantic v2, SQLite WAL, Pytest

Merkle SHA-256: 2aaec9b3754c39270a459aeab995bdd105a65e0d9629e7e74319e6d6bc09ae91

⚡ Ordenar / Desplegar en 1 Clic ($290 USD) →

LABORATORIO INTERACTIVO EN VIVO • O(1) RUNTIME SANDBOX ($0 TOKENS)

Prueba la Compuerta CRC-02 // EJECUTOR DE POLÍTICAS AST en Tiempo Real

SLA: <= 3.0 ms (Recorrido AST Estático)

Selecciona un escenario real o edita el payload para ver cómo reacciona la Máquina de Estados (FSM) y el Ledger SQLite WAL:

Nombre de Herramienta (`^[a-z][a-z0-9_]{1,63}$`)

Observación Cruda de Herramienta (`RawToolObservationDTO`)

Traza de Máquina de Estados Finita delta(S, E):

1. INGRESSED

2. SANITIZED

3. PARSED

4. GATE_VERDICT

5. WAL_COMMIT

6. AUDITED

✓ Commit Append-Only en SQLite WAL (`INV-08` & `INV-09`) CLASE: SEGURIDAD

Topología O(1): Inducción (Fase A) vs. Aduana (Fase B)

Separación física y criptográfica entre lo que el LLM propone y lo que el sistema autoriza ejecutar.

FASE A — Compilador Normativo CLAUDE.md (AST Estático • INV-01)

1. RulesFileIngress Digest SHA-256 + Validador de Formato

2. NormativeExtractor Extrae cláusulas 'Nunca / Prohibido'

3. ASTGuardCompiler Emite PATH_DENY / COMMAND_DENY / IMPORT_DENY

↓ Frontera Inviolable Default-Deny (<= 3.0 ms (Recorrido AST Estático), 0 LLMs • INV-02) ↓

FASE B — Ejecutor AST Fail-Closed + Ledger WAL Append-Only

ALLOW_COMPLIANT Cero reglas violadas -> Commit WAL

FLAG_UNENFORCEABLE Reporta prosa ambigua (Honestidad INV-04)

DENY_AST_GUARD Bloquea ruta, import o comando prohibido

Cartografía AST Certificada (`docs/system_manifest.json`):

DTO: RuleSourceFileDTO DTO: NaturalLanguageRuleDTO DTO: CompiledAstGuardDTO DTO: RuleComplianceAuditDTO DTO: CompiledRuleManifestDTO Tabla: compiled_rule_manifests Tabla: compiled_ast_guards Tabla: rule_enforcement_logs

Invariantes Negativas Selladas

Garantías matemáticas verificadas por Pytest y triggers SQLite WAL.

✓ INV-01 (Semántica Deny Estricta): Todo guard AST compilado es una regla de bloqueo; no existe constructor de reglas permisivas.
✓ INV-02 (Compilación Sin LLM): La compilación y aplicación de reglas son funciones puras deterministas sin llamadas a LLMs ni red.
✓ INV-03 (Contratos DTO Inmutables): Todos los DTOs imponen `frozen=True, extra='forbid'` y verifican hashes SHA-256 al instanciarse.
✓ INV-04 (Honestidad en Cláusulas Ambiguas): Toda cláusula que no pueda traducirse a un guard determinista se reporta y JAMÁS se declara aplicada.
✓ INV-06 (Rechazo de Comodines Globales): Los destinos comodín puros (`*`, `**`, `/`, `.`) se bloquean en Pydantic y en restricciones CHECK de SQLite.
✓ INV-08 (Bitácora Append-Only): Las tablas de manifiestos, guards y ejecuciones abortan cualquier `UPDATE` o `DELETE` directo mediante triggers WAL.

🔒 VITRINA GLASS-BOX PROTEGIDA • CABECERA VERIFICADA + NÚCLEO SELLADO

Inspecciona los Contratos y Manifiesto de la Cápsula (12 Artefactos)

Mostramos la firma pública e invariantes para certificar autoridad técnica; el cuerpo ejecutable completo se desbloquea en la descarga oficial.

🔒 Desbloquear los 12 Archivos ($290 USD) →

# SOLICITUD DE ARQUITECTURA PRE-VALIDADA: Claude Rules Compiler: Convierte Reglas de `CLAUDE.md` en Bloqueos AST Deterministas (SIG-1d0a63f087edb904)
Caso de Negocio DANTE: Entre el 84% y el 95.6% de las reglas escritas en `CLAUDE.md` o `.cursorrules` ('no tocar la base de producción', 'nunca subir secretos') dependen de la buena voluntad del modelo y son ignoradas bajo presión.

## 1. Invariantes Negativas No Negociables
1. El sistema jamás permitirá transiciones de estado fuera de la Máquina de Estados Finita (FSM) declarada.
2. El módulo nunca utilizará tipos float para montos financieros o métricas de precisión crítica; usará Decimal.
3. El servicio no deberá jamás ejecutar operaciones de escritura sin registrar evidencia en el ledger SQLite WAL.
4. Queda prohibido aceptar payloads con campos extra no declarados (`extra='forbid'` en Pydantic v2).
5. El sistema nunca expondrá secretos, llaves privadas ni trazas internas crudas hacia clientes externos.

## 2. Cotas Explícitas de Dominio
- Latencia de validación perimetral: rango [0.1 ms, 15.0 ms].
- Identificadores y hashes criptográficos: patrón regex `^[a-f0-9]{64}$`, longitud exacta 64 caracteres.
- Capacidad de lote transaccional: entero en rango [1, 1000].

## 3. Máquina de Estados Finita (FSM)
- Estados: INIT -> VALIDATED -> EXECUTING -> SEALED (Terminales: SEALED, QUARANTINED).
- Transiciones: delta(INIT, validate_ok) -> VALIDATED; delta(VALIDATED, execute_ok) -> EXECUTING; delta(EXECUTING, seal_merkle) -> SEALED; delta(*, invariant_violation) -> QUARANTINED.

## 4. Taxonomía de Errores (4 Clases) y Prueba Formal
- Clases: 1. Transitorios (IO/Lock), 2. Deterministas (Esquema Pydantic), 3. Negocio (Regla de dominio), 4. Seguridad (Inyección/Firma).
- Prueba formal de terminación: Acotada en O(N) pasos deterministas sin bucles abiertos.

"""
Claude Rules Compiler :: Contratos Inmutables Pydantic v2.
Signal: SIG-1d0a63f087edb904 | Proposal: PROP-1d0a63f087edb904-H2
ctxfw manifest_hash: b5b8e1cd10ce8beeed6b076f4726d19b361a6ce2f5d480c2bb2aa437986822d3
Protocol: CTXFW Axiomatic Gateway (status: VERIFIED, ACI: 1.0000)

Garantias:
  - Todos los DTOs: frozen=True, extra="forbid", str_strip_whitespace=True, validate_default=True.
  - INV-01: todo guard compilado es deny estricto; no existe constructor de reglas allow.
  - INV-06: targets comodin-only ('*', '**', '/', '.') jamas se aceptan (sin guards deny-all).
  - INV-09: compiled_rules_count siempre coincide con len(guards) del manifiesto.
  - FSM de dos etapas, total y determinista: transition(S, E), terminales EMITTED / REJECTED_INVALID.
"""
import hashlib
import re

# ══════════════════════════════════════════════════════════════════════════
# 🔒 [NÚCLEO DE IMPLEMENTACIÓN REDACTADO EN VITRINA PÚBLICA — PROTECCIÓN IP]
# Se ocultaron 203 líneas (7,707 bytes) de contratos ejecutables Pydantic v2, tabla FSM delta(S, E) y validadores SHA-256.
# 
# El código fuente completo sin redactar (12 archivos certificados + suite Pytest)
# se entrega desbloqueado y firmado con SHA-256 al adquirir la Cápsula ($290 USD):
# -> https://heuristicolab.com/es?prefill_slug=claude-rules-compiler
# ══════════════════════════════════════════════════════════════════════════

-- =============================================================================
-- Claude Rules Compiler :: Esquema Relacional DDL (SQLite WAL)
-- Signal: SIG-1d0a63f087edb904 | Proposal: PROP-1d0a63f087edb904-H2
-- ctxfw manifest_hash: b5b8e1cd10ce8beeed6b076f4726d19b361a6ce2f5d480c2bb2aa437986822d3
-- Protocol: CTXFW Axiomatic Gateway (status: VERIFIED, ACI: 1.0000)
--
-- Invariantes aplicadas a nivel de motor (fail-closed):
--   INV-06 : targets de guard jamas comodin (deny-all) ni vacios.
--   INV-08 : filas de manifiestos, guards y logs son append-only (ABORT en UPDATE);
--            guards y logs solo se eliminan por CASCADE desde su manifiesto padre.
--   INV-09 : guards insertados nunca exceden compiled_rules_count declarado.
-- Jerarquia: compiled_rule_manifests 1 --- N compiled_ast_guards 1 --- N rule_enforcement_logs
-- Compatible con SQLite >= 3.35 (tipado estricto via CHECK typeof, sin STRICT tables).
-- =============================================================================
PRAGMA journal_mode = WAL;

-- ══════════════════════════════════════════════════════════════════════════
-- 🔒 [NÚCLEO DE IMPLEMENTACIÓN REDACTADO EN VITRINA PÚBLICA — PROTECCIÓN IP]
-- Se ocultaron 105 líneas (5,341 bytes) de tablas relacionales SQLite WAL, restricciones CHECK(typeof) y triggers BEFORE UPDATE/DELETE.
-- 
-- El código fuente completo sin redactar (12 archivos certificados + suite Pytest)
-- se entrega desbloqueado y firmado con SHA-256 al adquirir la Cápsula ($290 USD):
-- -> https://heuristicolab.com/es?prefill_slug=claude-rules-compiler
-- ══════════════════════════════════════════════════════════════════════════

"""
Claude Rules Compiler :: Matriz TDD en memoria (sqlite3 :memory:).
Signal: SIG-1d0a63f087edb904 | Proposal: PROP-1d0a63f087edb904-H2
ctxfw manifest_hash: b5b8e1cd10ce8beeed6b076f4726d19b361a6ce2f5d480c2bb2aa437986822d3
Protocol: CTXFW Axiomatic Gateway (status: VERIFIED, ACI: 1.0000)

Contrato de ejecucion dual:
  - HermeticCompiler: las pruebas se ejecutan sin argumentos en el namespace del modulo
    `contracts` (cero I/O de disco; el DDL esta empotrado en DDL_SQL).
  - pytest autonomo: `python -m pytest specs/4_pytest_tdd_matrix.py` (carga contratos y
    verifica que DDL_SQL no se desvie de 3_schema_ddl.sql).

`ReferenceRulesCompiler` / `ReferenceEnforcer` son los ORACULOS de conformidad (especificacion
ejecutable). El satelite que implemente `src/claude_rules_compiler/` debe reproducir sus
resultados exactamente: mismas clausulas, mismos IDs, mismos guards, mismos veredictos.

# ══════════════════════════════════════════════════════════════════════════
# 🔒 [NÚCLEO DE IMPLEMENTACIÓN REDACTADO EN VITRINA PÚBLICA — PROTECCIÓN IP]
# Se ocultaron 168 líneas (7,611 bytes) de pruebas herméticas en memoria (sqlite3 :memory:) y oráculos de conformidad.
# 
# El código fuente completo sin redactar (12 archivos certificados + suite Pytest)
# se entrega desbloqueado y firmado con SHA-256 al adquirir la Cápsula ($290 USD):
# -> https://heuristicolab.com/es?prefill_slug=claude-rules-compiler
# ══════════════════════════════════════════════════════════════════════════

🔒 Protección de Propiedad Intelectual Soberana (Glass-Box IP Shield)

El núcleo ejecutable de validación, triggers SQLite WAL y suite hermética Pytest está truncado en la vitrina pública. Inyecta este contrato directamente en Checkout para recibir el paquete completo de 12 archivos firmados con SHA-256.

🔍 Auditar en AxiomSieve ⚡ Inyectar en Checkout ($290 USD) →

Preguntas Frecuentes Ejecutivas (GEO Verified)

¿Cómo resolver Claude Rules Compiler sin depender de filtros probabilísticos ni consultoras por hora?

Compila cada cláusula 'nunca / prohibido' en bloqueos duros (`PATH_DENY`, `COMMAND_DENY`, `IMPORT_DENY`) y reporta cualquier regla ambigua. Heurístico Lab entrega la cápsula certificada 'claude-rules-compiler' ($290 USD, 100% Pytest en verde y sello SHA-256).

¿Qué garantías técnicas aplica la cápsula CRC-02 // EJECUTOR DE POLÍTICAS AST en producción?

Aplica contratos Pydantic v2 inmutables (`extra='forbid'`), triggers append-only en SQLite WAL y ejecución O(1) (<= 3.0 ms (Recorrido AST Estático)).