higpertext-cli 0.8.0__py3-none-any.whl

higpertext/capabilities/security/scripts/k8s_auditor.py

@@ -0,0 +1,307 @@
+import os
+import argparse
+import datetime
+from pathlib import Path
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+
+class K8sAuditor:
+    def __init__(self, target_dir: Path):
+        self.target_dir = target_dir.resolve()
+        self.findings = []
+
+    def _should_skip_dir(self, root: str) -> bool:
+        return any(d in root for d in (".git", WORKSPACE_DIR_NAME, "venv", "__pycache__"))
+
+    def _scan_directory_files(self, yaml_extensions: set[str]) -> int:
+        files_scanned = 0
+        for root, _, files in os.walk(self.target_dir):
+            if self._should_skip_dir(root):
+                continue
+            for file in files:
+                file_path = Path(root) / file
+                if file_path.suffix in yaml_extensions:
+                    self.audit_file(file_path)
+                    files_scanned += 1
+        return files_scanned
+
+    def scan_files(self):
+        """Recursivamente busca archivos YAML y los audita."""
+        yaml_extensions = {".yaml", ".yml"}
+        if self.target_dir.is_file():
+            if self.target_dir.suffix in yaml_extensions:
+                self.audit_file(self.target_dir)
+                return 1
+            return 0
+        return self._scan_directory_files(yaml_extensions)
+
+    def audit_file(self, file_path: Path):
+        """Audita un manifiesto YAML buscando malas configuraciones de seguridad."""
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Separar documentos YAML si hay múltiples con ---
+            documents = content.split("---")
+            for doc_idx, doc in enumerate(documents, 1):
+                # Validar si tiene pinta de manifiesto K8s (debe tener apiVersion y kind)
+                if "apiVersion:" not in doc or "kind:" not in doc:
+                    continue
+
+                lines = doc.splitlines()
+                self._check_security_context(file_path, doc_idx, lines)
+                self._check_network_sharing(file_path, doc_idx, lines)
+                self._check_resource_limits(file_path, doc_idx, lines)
+        except Exception as e:
+            _log.warning(f"[!] Error leyendo {file_path.name}: {e}")
+
+    def _check_security_context(self, file_path: Path, doc_idx: int, lines: list):
+        """Audita el SecurityContext del Pod / Contenedores."""
+        has_run_as_non_root = False
+        has_read_only_root_fs = False
+        has_allow_privilege_escalation = False
+
+        in_security_context = False
+
+        for line_idx, line in enumerate(lines, 1):
+            clean_line = line.strip()
+
+            # Detectar si estamos en un bloque de securityContext
+            if clean_line.startswith("securityContext:"):
+                in_security_context = True
+                continue
+
+            # Salir de securityContext si la identación es menor (aproximado por espacios)
+            # Para simplificar, analizamos a nivel de línea en todo el archivo
+
+            if "privileged: true" in clean_line:
+                self.findings.append(
+                    {
+                        "id": "K8S-SEC-01",
+                        "title": "Contenedor Privilegiado Detectado",
+                        "severity": "CRITICAL",
+                        "category": "Privileged Mode",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)}:L{line_idx} (Doc {doc_idx})", # noqa: E501
+                        "description": "El contenedor se ejecuta en modo privilegiado, lo que le da acceso completo al host y anula los límites de aislamiento.", # noqa: E501
+                        "remediation": "Establecer `privileged: false` o remover la clave `privileged` del securityContext.", # noqa: E501
+                    }
+                )
+
+            if "runAsNonRoot: true" in clean_line:
+                has_run_as_non_root = True
+
+            if "runAsUser: 0" in clean_line:
+                self.findings.append(
+                    {
+                        "id": "K8S-SEC-02",
+                        "title": "Ejecución explícita como root (runAsUser: 0)",
+                        "severity": "CRITICAL",
+                        "category": "User Context",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)}:L{line_idx} (Doc {doc_idx})", # noqa: E501
+                        "description": "El contenedor está configurado explícitamente para ejecutarse con el usuario UID 0 (root).", # noqa: E501
+                        "remediation": "Configurar un usuario no root en el Dockerfile o cambiar `runAsUser` a un UID superior a 1000.", # noqa: E501
+                    }
+                )
+
+            if "readOnlyRootFilesystem: true" in clean_line:
+                has_read_only_root_fs = True
+
+            if "allowPrivilegeEscalation: true" in clean_line:
+                self.findings.append(
+                    {
+                        "id": "K8S-SEC-03",
+                        "title": "Permisión de Escalado de Privilegios (allowPrivilegeEscalation: true)", # noqa: E501
+                        "severity": "HIGH",
+                        "category": "Privilege Escalation",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)}:L{line_idx} (Doc {doc_idx})", # noqa: E501
+                        "description": "El proceso del contenedor puede adquirir más privilegios que su proceso padre.", # noqa: E501
+                        "remediation": "Establecer `allowPrivilegeEscalation: false` en el securityContext de cada contenedor.", # noqa: E501
+                    }
+                )
+
+        # Alertas por omisiones si es un Deployment o Pod
+        doc_str = "\n".join(lines)
+        if (
+            "kind: Pod" in doc_str
+            or "kind: Deployment" in doc_str
+            or "kind: StatefulSet" in doc_str
+            or "kind: DaemonSet" in doc_str
+        ):
+            if not has_run_as_non_root and "runAsNonRoot: false" not in doc_str:
+                self.findings.append(
+                    {
+                        "id": "K8S-SEC-04",
+                        "title": "Falta runAsNonRoot: true en el SecurityContext",
+                        "severity": "HIGH",
+                        "category": "User Context",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)} (Doc {doc_idx})", # noqa: E501
+                        "description": "El manifiesto no exige que el contenedor corra como un usuario no root.", # noqa: E501
+                        "remediation": "Agregar `runAsNonRoot: true` dentro del `securityContext` a nivel de Pod o Contenedor.", # noqa: E501
+                    }
+                )
+            if not has_read_only_root_fs:
+                self.findings.append(
+                    {
+                        "id": "K8S-SEC-05",
+                        "title": "Sistema de archivos raíz mutable (Root FS no de solo lectura)",
+                        "severity": "MEDIUM",
+                        "category": "Immutable Infrastructure",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)} (Doc {doc_idx})", # noqa: E501
+                        "description": "El contenedor puede escribir en su sistema de archivos raíz, lo que facilita persistencia de malware ante un compromiso.", # noqa: E501
+                        "remediation": "Agregar `readOnlyRootFilesystem: true` en el securityContext del contenedor y usar `emptyDir` o montajes específicos para directorios de escritura temporal.", # noqa: E501
+                    }
+                )
+
+    def _check_network_sharing(self, file_path: Path, doc_idx: int, lines: list):
+        """Revisa si comparte namespaces de red, PID o IPC con el host."""
+        for line_idx, line in enumerate(lines, 1):
+            clean_line = line.strip()
+            if "hostNetwork: true" in clean_line:
+                self.findings.append(
+                    {
+                        "id": "K8S-NET-01",
+                        "title": "Uso de hostNetwork de la máquina host",
+                        "severity": "HIGH",
+                        "category": "Host Namespace Sharing",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)}:L{line_idx} (Doc {doc_idx})", # noqa: E501
+                        "description": "El Pod comparte el espacio de nombres de red del host, permitiéndole sniffear tráfico de la máquina física.", # noqa: E501
+                        "remediation": "Eliminar `hostNetwork: true` y usar servicios/ingresses de Kubernetes para exponer la aplicación.", # noqa: E501
+                    }
+                )
+            if "hostPID: true" in clean_line:
+                self.findings.append(
+                    {
+                        "id": "K8S-NET-02",
+                        "title": "Uso de hostPID compartido",
+                        "severity": "CRITICAL",
+                        "category": "Host Namespace Sharing",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)}:L{line_idx} (Doc {doc_idx})", # noqa: E501
+                        "description": "El Pod comparte los procesos del host físico, pudiendo ver e interactuar con otros procesos de la máquina virtual/física.", # noqa: E501
+                        "remediation": "Remover `hostPID: true` del manifiesto.",
+                    }
+                )
+            if "hostIPC: true" in clean_line:
+                self.findings.append(
+                    {
+                        "id": "K8S-NET-03",
+                        "title": "Uso de hostIPC compartido",
+                        "severity": "CRITICAL",
+                        "category": "Host Namespace Sharing",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)}:L{line_idx} (Doc {doc_idx})", # noqa: E501
+                        "description": "El Pod comparte memoria IPC con el host, exponiendo comunicación inter-procesos compartida.", # noqa: E501
+                        "remediation": "Remover `hostIPC: true` del manifiesto.",
+                    }
+                )
+
+    def _check_resource_limits(self, file_path: Path, doc_idx: int, lines: list):
+        """Verifica la definición de límites de recursos para prevenir DoS."""
+        doc_str = "\n".join(lines)
+        if (
+            "kind: Pod" in doc_str
+            or "kind: Deployment" in doc_str
+            or "kind: StatefulSet" in doc_str
+            or "kind: DaemonSet" in doc_str
+        ):
+            # Si no hay especificaciones de límites
+            if "limits:" not in doc_str:
+                self.findings.append(
+                    {
+                        "id": "K8S-RES-01",
+                        "title": "Sin límites de recursos configurados (Dos Risk)",
+                        "severity": "LOW",
+                        "category": "Resource Management",
+                        "location": f"{file_path.relative_to(self.target_dir.parent)} (Doc {doc_idx})", # noqa: E501
+                        "description": "Los contenedores no tienen límites definidos de CPU o Memoria. Un bug (ej. memory leak) puede consumir todos los recursos del nodo físico y tumbar otros pods.", # noqa: E501
+                        "remediation": "Definir `resources.limits.cpu` y `resources.limits.memory` en la especificación del contenedor.", # noqa: E501
+                    }
+                )
+
+    def generate_report(self) -> str:
+        """Genera un reporte final estructurado en Markdown."""
+        report = [
+            "# 🛡️ Reporte de Auditoría de Manifiestos Kubernetes (K8s Security)",
+            f"\n**Fecha del Análisis**: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+            f"**Ruta Evaluada**: `{self.target_dir}`",
+            f"**Total de Hallazgos**: **{len(self.findings)}**",
+            "\n---",
+            "\n## 📊 Resumen Ejecutivo",
+            "| ID | Severidad | Categoría | Título | Ubicación |",
+            "|---|---|---|---|---|",
+        ]
+
+        # Ordenar por severidad
+        sev_map = {"CRITICAL": 0, "HIGH": 1, "MEDIUM": 2, "LOW": 3}
+        self.findings.sort(key=lambda x: sev_map.get(x["severity"], 4))
+
+        for f in self.findings:
+            sev_badge = (
+                f"**{f['severity']}**" if f["severity"] in {"CRITICAL", "HIGH"} else f["severity"]
+            )
+            report.append(f"| `{
+                    f['id']}` | {sev_badge} | {
+                    f['category']} | {
+                    f['title']} | `{
+                    f['location']}` |")
+
+        report.append("\n---")
+        report.append("\n## 🔍 Detalle de Hallazgos y Remediación")
+
+        if not self.findings:
+            report.append(
+                "\n> [!TIP]\n> **¡Excelente!** No se detectaron fallos de seguridad en los manifiestos YAML auditados." # noqa: E501
+            )
+        else:
+            for idx, f in enumerate(self.findings, 1):
+                report.append(f"\n### {idx}. [{f['severity']}] {f['title']} (`{f['id']}`)")
+                report.append(f"- **Categoría**: {f['category']}")
+                report.append(f"- **Ubicación**: `{f['location']}`")
+                report.append(f"- **Descripción**: {f['description']}")
+                report.append(f"\n#### 🛠️ Instrucciones de Remediación:")
+                report.append(f"> {f['remediation']}\n")
+
+        return "\n".join(report)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Auditor de Manifiestos K8s de higpertext")
+    parser.add_argument("--target", default=".", help="Ruta al archivo o carpeta a escanear")
+    parser.add_argument(
+        "--save_report",
+        default="k8s_security_report.md",
+        help="Nombre del archivo de reporte",
+    )
+
+    args, unknown = parser.parse_known_args()
+
+    target_path = Path(args.target).resolve()
+    auditor = K8sAuditor(target_path)
+
+    files_scanned = auditor.scan_files()
+    report_md = auditor.generate_report()
+
+    # Imprimir en consola
+    _log.info(f"[*] Escaneo finalizado. Se analizaron {files_scanned} archivos YAML.")
+    _log.info(report_md)
+
+    # Guardar en archivo
+    reports_dir = target_path / WORKSPACE_DIR_NAME / "reportes"
+    if not reports_dir.exists():
+        # Fallback a carpeta local si es un archivo o directorio externo
+        reports_dir = Path.cwd() / WORKSPACE_DIR_NAME / "reportes"
+
+    reports_dir.mkdir(parents=True, exist_ok=True)
+    out_file = reports_dir / Path(args.save_report).name
+
+    try:
+        with open(out_file, "w", encoding="utf-8") as f:
+            f.write(report_md)
+        _log.ok(f"\n[SUCCESS] Reporte guardado en: {out_file}")
+    except Exception as e:
+        _log.warning(f"[!] Error guardando reporte: {e}")
+
+
+if __name__ == "__main__":
+    main()

higpertext/capabilities/security/scripts/secret_scanner.py

@@ -0,0 +1,235 @@
+import os
+import re
+import argparse
+import datetime
+from pathlib import Path
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+
+class SecretScanner:
+    def __init__(self, target_dir: Path):
+        self.target_dir = target_dir.resolve()
+        self.findings = []
+
+        # Patrones regex de detección de secretos
+        self.patterns = [
+            {
+                "id": "SEC-PAT-01",
+                "name": "Azure DevOps Personal Access Token (PAT)",
+                "regex": r"(?:^|[^a-zA-Z0-9])([a-z2-7][a-z0-9]{51})(?:$|[^a-zA-Z0-9])",
+                "severity": "CRITICAL",
+                "remediation": (
+                    "Revocar el PAT inmediatamente en el portal de Azure DevOps "
+                    "y moverlo a Azure Key Vault o variables de entorno."
+                ),
+            },
+            {
+                "id": "SEC-AWS-01",
+                "name": "AWS Access Key ID",
+                "regex": r"AKIA[0-9A-Z]{16}",
+                "severity": "CRITICAL",
+                "remediation": "Inhabilitar la clave en la consola de AWS IAM y rotarla de inmediato.", # noqa: E501
+            },
+            {
+                "id": "SEC-KEY-01",
+                "name": "Clave Privada PEM / SSH",
+                "regex": r"-----BEGIN [A-Z ]+ PRIVATE KEY-----",
+                "severity": "CRITICAL",
+                "remediation": (
+                    "Mover la clave privada fuera del control de código fuente "
+                    "y revocar cualquier acceso asociado."
+                ),
+            },
+            {
+                "id": "SEC-PWD-01",
+                "name": "Contraseña Hardcodeada Posible",
+                "regex": (
+                    r"(?:password|passwd|pwd|db_pass|client_secret)\s*=\s*"
+                    r"['\"]([^'\"]{4,})['\"]"
+                ),
+                "severity": "HIGH",
+                "remediation": (
+                    "Extraer la contraseña a un archivo de configuración "
+                    "secreto (.env) o cargarlo a través de un proveedor de "
+                    "secretos de infraestructura."
+                ),
+            },
+        ]
+
+    def scan_files(self) -> int:
+        files_scanned = 0
+
+        if self.target_dir.is_file():
+            self.audit_file(self.target_dir)
+            files_scanned += 1
+        else:
+            for root, _, files in os.walk(self.target_dir):
+                if (
+                    ".git" in root
+                    or WORKSPACE_DIR_NAME in root
+                    or "venv" in root
+                    or "__pycache__" in root
+                    or "node_modules" in root
+                ):
+                    continue
+                for file in files:
+                    file_path = Path(root) / file
+                    # Solo escanear archivos de texto legibles
+                    valid_exts = {
+                        ".py",
+                        ".json",
+                        ".md",
+                        ".env",
+                        ".txt",
+                        ".ps1",
+                        ".yml",
+                        ".yaml",
+                        ".ini",
+                        ".con",
+                        ".cfg",
+                    }
+                    if file_path.suffix in valid_exts:
+                        self.audit_file(file_path)
+                        files_scanned += 1
+
+        return files_scanned
+
+    def audit_file(self, file_path: Path):
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                lines = f.readlines()
+        except Exception:
+            return
+
+        for line_idx, line in enumerate(lines, 1):
+            # Saltar comentarios de documentación obvios
+            if line.strip().startswith("#") and "api_key" not in line.lower():
+                continue
+
+            for p in self.patterns:
+                matches = re.findall(p["regex"], line)
+                if matches:
+                    for m in matches:
+                        # Si es una asignación de contraseña, la contraseña es el match group 1.
+                        # De lo contrario es la coincidencia completa.
+                        secret_value = m if isinstance(m, str) else m[0]
+
+                        # Evitar detectar variables vacías o marcadores de posición
+                        common_placeholders = {
+                            "your_password",
+                            "placeholder",
+                            "admin",
+                            "null",
+                            "none",
+                            "password",
+                        }
+                        if secret_value.strip().lower() in common_placeholders:
+                            continue
+
+                        masked = self.mask_secret(secret_value)
+
+                        self.findings.append(
+                            {
+                                "id": p["id"],
+                                "title": p["name"],
+                                "severity": p["severity"],
+                                "location": (
+                                    f"{file_path.relative_to(self.target_dir.parent)}"
+                                    f":L{line_idx}"
+                                ),
+                                "masked_value": masked,
+                                "remediation": p["remediation"],
+                            }
+                        )
+
+    def mask_secret(self, secret: str) -> str:
+        """Enmascara el secreto dejando legibles solo los extremos."""
+        if len(secret) <= 6:
+            return "*****"
+        return f"{secret[:3]}*****{secret[-3:]}"
+
+    def generate_report(self) -> str:
+        report = [
+            "# 🛡️ Reporte de Auditoría de Credenciales y Secretos Expuestos",
+            f"\n**Fecha del Análisis**: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+            f"**Ruta Evaluada**: `{self.target_dir}`",
+            f"**Total de Hallazgos**: **{len(self.findings)}**",
+            "\n---",
+            "\n## 📊 Resumen Ejecutivo",
+            "| ID | Severidad | Credencial / Secreto Detectado | Ubicación | Valor Enmascarado |",
+            "|---|---|---|---|---|",
+        ]
+
+        # Ordenar por criticidad
+        sev_map = {"CRITICAL": 0, "HIGH": 1, "MEDIUM": 2, "LOW": 3}
+        self.findings.sort(key=lambda x: sev_map.get(x["severity"], 4))
+
+        for f in self.findings:
+            sev_badge = (
+                f"**{f['severity']}**" if f["severity"] in {"CRITICAL", "HIGH"} else f["severity"]
+            )
+            report.append(f"| `{
+                    f['id']}` | {sev_badge} | {
+                    f['title']} | `{
+                    f['location']}` | `{
+                    f['masked_value']}` |")
+
+        report.append("\n---")
+        report.append("\n## 🔍 Detalle de Alertas y Acciones Correctivas")
+
+        if not self.findings:
+            report.append(
+                "\n> [!TIP]\n> **¡Excelente!** No se detectaron credenciales ni "
+                "secretos expuestos en la ruta auditada."
+            )
+        else:
+            for idx, f in enumerate(self.findings, 1):
+                report.append(f"\n### {idx}. [{f['severity']}] {f['title']} (`{f['id']}`)")
+                report.append(f"- **Ubicación**: `{f['location']}`")
+                report.append(f"- **Valor Enmascarado**: `{f['masked_value']}`")
+                report.append("\n#### 🛠️ Guía de Remediación:")
+                report.append(f"> {f['remediation']}\n")
+
+        return "\n".join(report)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="higpertext Security Credential Scanner")
+    parser.add_argument(
+        "--target_path", default=".", help="Ruta al archivo o directorio a escanear"
+    )
+    parser.add_argument(
+        "--output_report",
+        default="secret_scan_report.md",
+        help="Nombre del reporte de salida",
+    )
+
+    args, unknown = parser.parse_known_args()
+
+    target_path = Path(args.target_path).resolve()
+    scanner = SecretScanner(target_path)
+
+    files_scanned = scanner.scan_files()
+    report_md = scanner.generate_report()
+
+    _log.info(f"[*] Escaneo de secretos completado. Se escanearon {files_scanned} archivos.")
+    _log.info(report_md)
+
+    # Guardar reporte
+    reports_dir = Path.cwd() / WORKSPACE_DIR_NAME / "reportes"
+    reports_dir.mkdir(parents=True, exist_ok=True)
+    out_file = reports_dir / Path(args.output_report).name
+
+    try:
+        with open(out_file, "w", encoding="utf-8") as f:
+            f.write(report_md)
+        _log.ok(f"\n[SUCCESS] Reporte de secretos guardado en: {out_file}")
+    except Exception as e:
+        _log.warning(f"[!] Error escribiendo reporte: {e}")
+
+
+if __name__ == "__main__":
+    main()

higpertext/capabilities/security/secret-scanner.json

@@ -0,0 +1,32 @@
+{
+    "id": "security.secret-scanner",
+    "version": "1.0.0",
+    "name": "Escáner de Secretos y Credenciales (Secret Scanner)",
+    "description": "Escanea el código fuente e historial en busca de claves API expuestas, PATs, tokens y contraseñas.",
+    "entrypoint": "capabilities/security/scripts/secret_scanner.py",
+    "language": "python",
+    "parameters": [
+        {
+            "name": "target_path",
+            "type": "string",
+            "required": false,
+            "default": ".",
+            "description": "Directorio o archivo a escanear en busca de secretos."
+        },
+        {
+            "name": "output_report",
+            "type": "string",
+            "required": false,
+            "default": "secret_scan_report.md",
+            "description": "Nombre del archivo de reporte Markdown resultante."
+        }
+    ],
+    "contract": {
+        "format": "Markdown Secret Scan Report",
+        "rules": [
+            "Debe buscar claves API, contraseñas, PATs de Azure DevOps, tokens de AWS y claves privadas.",
+            "Debe enmascarar los secretos encontrados en el reporte de salida para evitar filtraciones secundarias.",
+            "Debe clasificar los hallazgos según la criticidad del secreto."
+        ]
+    }
+}

higpertext/hooks/__init__.py

@@ -0,0 +1,28 @@
+"""higpertext Hooks — sistema nativo de hooks, tasks y webhooks.
+
+Re-exporta la API pública para mantener compatibilidad con imports externos
+del estilo `from higpertext.hooks.X import Y` sin cambios en los consumidores.
+"""
+
+# domain
+from higpertext.kernel.domain.hook_models import HookDefinition, WebhookEvent  # noqa: F401
+
+# application
+from higpertext.kernel.application.hook_registry import HookRegistry  # noqa: F401
+from higpertext.kernel.application.hook_renderer import HookRenderer  # noqa: F401
+from higpertext.kernel.application.skill_hook_compiler import (  # noqa: F401
+    SkillHookCompiler,
+)
+
+# infrastructure
+from higpertext.kernel.infrastructure.hook_config_loader import (  # noqa: F401
+    load_hooks_config,
+    save_hooks_config,
+)
+from higpertext.kernel.infrastructure.hook_webhook_dispatcher import (  # noqa: F401
+    WebhookDispatcher,
+)
+from higpertext.kernel.infrastructure.hook_workflow_bridge import (  # noqa: F401
+    WorkflowHookBridge,
+    WorkflowHookEntry,
+)

higpertext/hooks/_compat.py

@@ -0,0 +1,27 @@
+"""Single shim — all hooks re-exports from infrastructure, application, and domain layers."""
+
+# Domain
+from higpertext.kernel.domain.hook_models import (  # noqa: F401
+    HookDefinition,
+    WebhookEvent,
+)
+
+# Application
+from higpertext.kernel.application.hook_registry import HookRegistry  # noqa: F401
+from higpertext.kernel.application.hook_renderer import HookRenderer  # noqa: F401
+from higpertext.kernel.application.skill_hook_compiler import (  # noqa: F401
+    SkillHookCompiler,
+)
+
+# Infrastructure
+from higpertext.kernel.infrastructure.hook_config_loader import (  # noqa: F401
+    load_hooks_config,
+    save_hooks_config,
+)
+from higpertext.kernel.infrastructure.hook_webhook_dispatcher import (  # noqa: F401
+    WebhookDispatcher,
+)
+from higpertext.kernel.infrastructure.hook_workflow_bridge import (  # noqa: F401
+    WorkflowHookBridge,
+    WorkflowHookEntry,
+)

higpertext/hooks/hook_tasks/__init__.py

@@ -0,0 +1 @@
+"""Hook tasks autónomas — interfaz stdin/stdout JSON."""