@christianmaf80/agentic-workflow 1.8.0-beta.1 → 1.11.0-beta.1

package/dist/artifacts/11-revision-sistema-agentic/researcher/research.md

@@ -0,0 +1,131 @@
+---
+artifact: research
+phase: phase-1-research
+owner: researcher-agent
+status: draft
+related_task: 11-revision-sistema-agentic
+---
+
+# Research Report — 11-revision-sistema-agentic
+
+## 1. Resumen ejecutivo
+
+### Problema investigado
+Las constituciones actuales de **Modules**, **Pages** y **Shards** carecen de la profundidad técnica necesaria para que los agentes (AI) implementen correctamente estos componentes del framework Extensio. Los workflows asociados son incompletos y no garantizan la integración correcta con el sistema de build del CLI.
+
+### Objetivo de la investigación
+Identificar las debilidades específicas en las constituciones y workflows, y proponer un conjunto de mejoras basadas en la arquitectura del framework, el CLI existente y las buenas prácticas de extensiones multi-browser.
+
+### Principales hallazgos
+1. **Shards**: No existe una regla clara sobre el patrón "Adapter" (Lit/React/Vanilla) ni sobre el mecanismo de transformación de imports en tiempo de build.
+2. **Pages**: La constitución actual tiene solo 3 secciones mínimas y no cubre: ciclo de vida, estilos, navegación programática ni integración con el índice de superficies.
+3. **Modules**: Aunque más completa, tiene duplicación con `extensio-architecture.md` y carece de ejemplos sobre comunicación Engine↔Context↔Surface.
+4. **Workflows**: `pages.create.md` y `shards.create.md` existen pero son esquemáticos (5-6 líneas cada uno) y no tienen validaciones de arquitectura.
+
+---
+
+## 2. Necesidades detectadas
+
+### Requisitos técnicos identificados
+- Definir el contrato técnico del **Shard** como WebComponent registrable.
+- Documentar el flujo de build para Shards (detección, compilación independiente, transformación de imports).
+- Establecer el ciclo de vida de una **Page** y su relación con el Engine (navegación y paso de datos).
+- Crear workflows con "Gates" que validen la estructura antes de permitir avanzar.
+
+### Suposiciones y límites
+- El CLI (`extensio-cli`) es la fuente de verdad para el scaffolding. Los agentes deben usar `mcp_extensio-cli` como herramienta principal.
+- No se modificará la lógica interna del Core (Engine, Context, Shard base classes) en esta tarea; solo la documentación contractual.
+
+---
+
+## 3. Alternativas técnicas
+
+### A. Refactorizar las constituciones existentes
+- **Descripción**: Actualizar `modules.md`, `pages.md` y `shards.md` in-place con las nuevas reglas.
+- **Pros**: Menor número de archivos, historial de cambios claro.
+- **Contras**: Posible pérdida de reglas antiguas durante el refactor.
+- **Riesgo**: Medio.
+- **Impacto**: Alto (mejora directa de la interpretación por agentes).
+
+### B. Crear nuevas constituciones con versionado
+- **Descripción**: Mantener los archivos actuales como `v1` y crear `modules.v2.md`, etc.
+- **Pros**: Retrocompatibilidad explícita.
+- **Contras**: Complejidad adicional en el sistema de reglas, mayor carga cognitiva para los agentes.
+- **Riesgo**: Bajo.
+- **Impacto**: Medio.
+
+### C. Unificar en un único documento de arquitectura
+- **Descripción**: Fusionar todo en `extensio-architecture.md`.
+- **Pros**: Única fuente de verdad.
+- **Contras**: Archivo muy largo; difícil de mantener y cargar en contexto de LLMs.
+- **Riesgo**: Alto.
+- **Impacto**: Negativo (empeora la mantenibilidad).
+
+**Recomendación**: Alternativa **A** (refactorizar in-place).
+
+---
+
+## 4. APIs Web / WebExtensions relevantes
+
+| API / Especificación | Estado Chrome | Estado Firefox | Estado Safari | Notas |
+|----------------------|---------------|----------------|---------------|-------|
+| `customElements.define` | ✅ Estable | ✅ Estable | ✅ Estable | Base para WebComponents/Shards |
+| `chrome.scripting.executeScript` | ✅ MV3 | ✅ (con polyfill) | ⚠️ Limitado | Usado por `loadShard` |
+| `chrome.runtime.getURL` | ✅ Estable | ✅ Estable | ✅ Estable | Resolución de assets |
+| `chrome.tabs.create` / `update` | ✅ Estable | ✅ Estable | ✅ Estable | Navegación a Pages |
+| HTML Imports (deprecated) | ❌ Eliminado | ❌ Eliminado | ❌ Eliminado | No usar; reemplazar con ES Modules |
+
+---
+
+## 5. Compatibilidad multi-browser
+
+| Característica | Chrome | Firefox | Safari | Edge |
+|----------------|--------|---------|--------|------|
+| WebComponents v1 | ✅ | ✅ | ✅ | ✅ |
+| ES Modules en content scripts | ✅ | ✅ | ⚠️ Experimental | ✅ |
+| Manifest V3 | ✅ | 🚧 Parcial | ❌ MV2 only | ✅ |
+
+### Estrategias de mitigación
+- Para Safari: mantener fallback a MV2 y evitar uso de APIs exclusivas de MV3.
+- Para Firefox: usar polyfills del `webextension-polyfill` cuando aplique.
+
+---
+
+## 6. Recomendaciones AI-first
+
+| Oportunidad | API/Patrón Habilitador | Impacto Esperado |
+|-------------|------------------------|------------------|
+| Generación automática de Shards | `mcp_extensio-cli_extensio_create` con flags `--withShards` | Alto: reduce errores de scaffolding |
+| Validación de estructura en workflows | Gates con checklist verificable (archivos, exports, registros) | Alto: bloquea implementaciones incompletas |
+| Detección de errores de build pre-commit | Integración de `mcp_extensio-cli_extensio_build` en Phase 5 | Medio: feedback temprano |
+
+---
+
+## 7. Riesgos y trade-offs
+
+| Riesgo | Severidad | Mitigación |
+|--------|-----------|------------|
+| Constituciones muy extensas saturan el contexto del LLM | Media | Usar reglas `MEMORY` para recordar sin reinyectar texto completo |
+| Cambios en workflows rompen tareas en curso | Baja | Los workflows se cargan al inicio de la tarea; tareas activas usan la versión cargada |
+| Desalineación entre CLI templates y constitución | Alta | Sincronizar cambios de constitución con actualización de templates en `packages/cli/src/generators` |
+
+---
+
+## 8. Fuentes
+
+- [WebExtensions API (MDN)](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions)
+- [Chrome Extension Manifest V3](https://developer.chrome.com/docs/extensions/mv3/)
+- [Custom Elements Spec (WHATWG)](https://html.spec.whatwg.org/multipage/custom-elements.html)
+- [Lit Element Docs](https://lit.dev/)
+- Código fuente de Extensio: `packages/core/src/surface/shards/`, `packages/cli/src/commands/process-shards.mts`
+
+---
+
+## 9. Aprobación del desarrollador (OBLIGATORIA)
+```yaml
+approval:
+  developer:
+    decision: 
+    date: 
+    comments: 
+```

package/dist/artifacts/11-revision-sistema-agentic/results.md

@@ -0,0 +1,116 @@
+# Informe de Resultados - Phase 6
+
+## Tarea: 11-revision-sistema-agentic
+## Título: Revisión de Constitución y Workflows Agénticos
+## Fecha: 2026-01-13T23:52:00+01:00
+
+---
+
+## 1. Resumen Ejecutivo
+
+La tarea de revisión del sistema agéntico ha sido completada exitosamente. Se han actualizado las constituciones, workflows y roles para garantizar coherencia arquitectónica en el framework Extensio.
+
+---
+
+## 2. Entregables Finales
+
+### 2.1 Constituciones Actualizadas
+
+| Archivo | Antes | Después | Cambio |
+|---------|-------|---------|--------|
+| `extensio-architecture.md` | 341 líneas | 131 líneas | Reducido a principios generales |
+| `modules.md` | 225 líneas | 250 líneas | v2.0.0 - Consolidado |
+| `pages.md` | 21 líneas | 454 líneas | v2.1.0 - Nuevo completo |
+| `shards.md` | 24 líneas | 484 líneas | v2.0.0 - Nuevo completo |
+
+### 2.2 Workflows Actualizados
+
+| Archivo | Antes | Después | Cambio |
+|---------|-------|---------|--------|
+| `modules/create.md` | 105 líneas | 126 líneas | v2.0.0 - Verificación Surfaces |
+| `modules/pages.create.md` | 12 líneas | 202 líneas | v2.0.0 - Completo |
+| `modules/shards.create.md` | 11 líneas | 183 líneas | v2.0.0 - Completo |
+
+### 2.3 Roles Actualizados
+
+| Archivo | Antes | Después | Cambio |
+|---------|-------|---------|--------|
+| `roles/module.md` | 128 líneas | 145 líneas | v2.0.0 - Delegación Surfaces |
+
+### 2.4 Índices Actualizados
+
+| Archivo | Versión |
+|---------|---------|
+| `rules/constitution/index.md` | v2.0.0 |
+| `workflows/modules/index.md` | v2.0.0 |
+
+---
+
+## 3. Decisiones Arquitectónicas
+
+### 3.1 Separación Architecture vs Constituciones
+- `extensio-architecture.md` contiene solo principios generales
+- Cada constitución contiene reglas detalladas de su componente
+
+### 3.2 Jerarquía de Surfaces
+- Definida: `Core → Surface → Page` y `Core → Surface → Shard`
+- Shard debe heredar de Surface (cambio de código pendiente)
+
+### 3.3 Hooks Automáticos
+- `onMount()`: Se ejecuta automáticamente DESPUÉS de render()
+- `onUnmount()`: Se ejecuta automáticamente ANTES de destruir
+
+### 3.4 Responsabilidades de Pages (SRP)
+- §11: Solo lógica de presentación, interacción y orquestación de Shards
+- §12: No estado persistente de negocio
+
+### 3.5 Shards sin Lógica de Negocio
+- Solo reactividad, acciones y renderizado
+- La lógica de negocio la controla Page o Engine
+
+---
+
+## 4. Impacto Documentado
+
+### 4.1 Core (core-impact.md)
+- Shard debe heredar de Surface
+- onMount debe ser automático post-render
+- Añadir render() abstracto a Surface
+
+### 4.2 CLI/MCP (cli-mcp-impact.md)
+- Template page.ts.ejs incompleto (2 líneas)
+- Template shard.ts.ejs sin getTagName()
+- No hay comandos add-shard/add-page
+
+---
+
+## 5. Criterios de Aceptación - Estado Final
+
+| # | Criterio | Estado |
+|---|----------|--------|
+| 1 | Constituciones modules, pages, shards robustas | ✅ Completado |
+| 2 | Workflows pages.create y shards.create | ✅ Completado |
+| 3 | Informe de impacto CLI/MCP | ✅ Completado |
+| 4 | Sin romper retrocompatibilidad | ✅ Solo documentación |
+| 5 | Aprobación del desarrollador | ✅ SI |
+
+---
+
+## 6. Trabajo Futuro (Fuera de alcance)
+
+1. **Tarea de Core**: Implementar cambios de código (Shard hereda Surface)
+2. **Tarea de CLI**: Actualizar templates de Page y Shard
+3. **Tarea de CLI**: Añadir comandos add-shard/add-page
+
+---
+
+## 7. Aprobación
+
+**Estado**: ✅ APROBADO
+
+**Aprobado por**: Desarrollador
+**Fecha**: 2026-01-13T23:52:00+01:00
+
+---
+
+Generado por: architect-agent

package/dist/artifacts/11-revision-sistema-agentic/shards-v2.md

@@ -0,0 +1,424 @@
+---
+trigger: model_decision
+description: Se aplica cuando se crean, modifican o auditan Shards, o cuando un agente toma decisiones sobre ellos, garantizando estructura contractual, ciclo de vida y cumplimiento arquitectónico.
+---
+
+---
+id: constitution.shards
+type: rule
+owner: architect-agent
+version: 2.0.0
+severity: PERMANENT
+scope: global
+---
+
+# CONSTITUTION: Shards (Extensio)
+
+## Objetivo
+Este documento define **reglas obligatorias** y contractuales para los Shards de Extensio.
+Todo Shard **DEBE** cumplir estas reglas.
+Los agentes **DEBEN** auditar y hacer cumplir este contrato.
+
+---
+
+## 1. Definición (qué es un Shard)
+
+Un Shard es un **componente visual reutilizable** que se representa dentro de una Page o en una página de navegación orgánica.
+
+Un Shard:
+- Es un WebComponent registrado con `customElements.define()`
+- Hereda de la clase `Surface` que extiende `Core`
+- Tiene reactividad mediante `@property` y `@onChanged`
+- Puede usar cualquier sistema de renderizado (Lit, React, Vanilla, etc.)
+- Recibe estado y lo renderiza
+
+Un Shard **NO**:
+- Contiene lógica de negocio
+- Almacena estado persistente de negocio
+- Toma decisiones de dominio
+- Ejecuta operaciones que afecten otras partes de la extensión
+
+---
+
+## 2. Jerarquía de Clases
+
+```
+Core
+  └── Surface (clase abstracta)
+        └── Shard (clase abstracta)
+              ├── LitShard (ejemplo - no oficial)
+              └── ReactShard (ejemplo - no oficial)
+```
+
+### Clase Base: `Surface`
+
+La clase `Surface` proporciona hooks de ciclo de vida compartidos con Page:
+- `onMount()`: Se ejecuta cuando la Surface está lista en el DOM
+- `onUnmount()`: Se ejecuta antes de destruir la Surface
+- Integración con Storage reactivo
+- Gestión de listeners
+
+### Clase: `Shard`
+
+La clase `Shard` extiende `Surface` y añade:
+- Registro como WebComponent: `Shard.register(tagName, Class)`
+- Ciclo de renderizado: `mount()` → `render()` → `unmount()`
+- Estados: `Loading`, `Mounted`, `Unmounted`, `Error`
+- Comunicación con Engine: `notifyEngine()`, `notifyShardState()`
+- Métodos abstractos: `_mount()`, `_unmount()`, `update()`, `getTagName()`
+
+---
+
+## 3. Estructura Obligatoria
+
+Cada Shard **DEBE** seguir esta estructura dentro del módulo:
+
+```
+packages/modules/<module-name>/
+└── src/
+    └── surface/
+        └── shards/
+            ├── index.mts              # Índice de registro (OBLIGATORIO)
+            └── <shard-name>/
+                ├── index.mts          # Implementación del Shard
+                └── styles.css         # Estilos (opcional)
+```
+
+### 3.1 Índice de Shards (`src/surface/shards/index.mts`)
+
+Este archivo es **OBLIGATORIO** si el módulo define Shards.
+
+**Responsabilidad**:
+- Importar todos los Shards del módulo
+- Registrar cada Shard como WebComponent
+- Exportar los Shards para uso programático
+
+```ts
+// src/surface/shards/index.mts
+import { Shard } from '@extensio/core/shard';
+import { MyShard } from './my-shard/index.mts';
+import { AnotherShard } from './another-shard/index.mts';
+
+// Registrar WebComponents (OBLIGATORIO)
+Shard.register('my-module-shard', MyShard);
+Shard.register('my-module-another', AnotherShard);
+
+// Exportar para uso programático
+export { MyShard, AnotherShard };
+```
+
+### 3.2 Implementación del Shard
+
+Cada Shard **DEBE** implementar:
+
+```ts
+// my-shard/index.mts
+import { Shard } from '@extensio/core/shard';
+import type { ShardContext } from '@extensio/core/shard';
+
+export class MyShard extends Shard {
+  constructor(context: ShardContext) {
+    super('my-shard', context);
+  }
+
+  // OBLIGATORIO: Nombre del tag para WebComponent
+  getTagName(): string {
+    return 'my-module-shard';
+  }
+
+  // OBLIGATORIO: Montar el componente en el contenedor
+  protected async _mount(container: HTMLElement): Promise<void> {
+    container.innerHTML = '<div class="my-shard">Loading...</div>';
+  }
+
+  // OBLIGATORIO: Actualizar con nuevas propiedades
+  update(props: Record<string, any>): void {
+    // Re-renderizar con nuevas props
+  }
+
+  // OBLIGATORIO: Limpiar antes de destruir
+  protected _unmount(): void {
+    // Cleanup
+  }
+
+  // OPCIONAL: Renderizado personalizado
+  public async render(): Promise<void> {
+    // Implementación de renderizado
+  }
+}
+```
+
+---
+
+## 4. Ciclo de Vida
+
+### 4.1 Estados del Shard
+
+| Estado | Descripción |
+|--------|-------------|
+| `Loading` | El Shard se está montando |
+| `Mounted` | El Shard está activo y renderizado |
+| `Unmounted` | El Shard ha sido desmontado |
+| `Error` | Ocurrió un error durante el ciclo de vida |
+
+### 4.2 Secuencia de Ejecución
+
+| # | Método | Tipo | Descripción |
+|---|--------|------|-------------|
+| 1 | `constructor(context)` | Público | Inicializa con contexto (tabId, url, etc.) |
+| 2 | `mount(container)` | Público | Punto de entrada. Dispara el ciclo. |
+| 3 | `notifyShardState(Loading)` | Interno | Notifica al Engine que está cargando |
+| 4 | `_mount(container)` | Abstracto | Implementación del montaje (subclase) |
+| 5 | `render()` | Público | Renderiza el contenido |
+| 6 | `notifyShardState(Mounted)` | Interno | Notifica al Engine que está montado |
+| 7 | `update(props)` | Abstracto | Actualiza con nuevas propiedades |
+| 8 | `unmount()` | Público | Desmonta el componente |
+| 9 | `_unmount()` | Abstracto | Implementación del desmontaje |
+| 10 | `notifyShardState(Unmounted)` | Interno | Notifica al Engine que fue desmontado |
+
+### 4.3 Hooks de Surface
+
+Los Shards heredan de Surface, por lo que también tienen:
+- `onMount()`: Se puede usar para inicialización adicional
+- `onUnmount()`: Se puede usar para cleanup adicional
+
+---
+
+## 5. Registro como WebComponent
+
+### 5.1 Método de Registro
+
+Todo Shard **DEBE** registrarse antes de poder usarse:
+
+```ts
+import { Shard } from '@extensio/core/shard';
+
+Shard.register('my-tag-name', MyShardClass);
+```
+
+### 5.2 Reglas de Naming
+
+| Elemento | Convención | Ejemplo |
+|----------|------------|---------|
+| Tag WebComponent | kebab-case con prefijo de módulo | `my-module-widget` |
+| Clase Shard | PascalCase + `Shard` | `MyModuleWidgetShard` |
+| Carpeta | kebab-case | `widget/` |
+
+### 5.3 Prevención de Duplicados
+
+El método `Shard.register()` previene registros duplicados:
+- Si el tag ya existe, muestra warning y retorna `false`
+- Si es nuevo, lo registra y retorna `true`
+
+---
+
+## 6. Dos Contextos de Uso
+
+### 6.1 Dentro de una Page (Orquestador: Page)
+
+```ts
+// En la Page
+import { MyShard } from './surface/shards/index.mts';
+
+class MyPage extends Page {
+  override start() {
+    // El Shard ya está registrado como WebComponent
+    const container = document.getElementById('shard-container');
+    const shard = new MyShard({ tabId: 0, url: window.location.href });
+    shard.mount(container);
+  }
+}
+```
+
+### 6.2 En Navegación Orgánica (Orquestador: Engine)
+
+El Engine carga Shards en páginas web externas mediante `loadShard()`:
+
+```ts
+// En el Engine
+import { MyShard } from './surface/shards/index.mts';
+
+class MyEngine extends Engine {
+  override start() {
+    // Cargar shard en la página actual del navegador
+    this.loadShard(MyShard);
+  }
+
+  // Escuchar eventos del Shard
+  @onShard('my-shard', ShardStatus.Mounted)
+  onMyShardMounted(state: ShardState) {
+    this.log('Shard montado:', state);
+  }
+}
+```
+
+### 6.3 Transformación del CLI
+
+El CLI detecta el uso de `loadShard()` y transforma el código:
+
+```ts
+// Código fuente
+import { MyShard } from './surface/shards/MyShard.mts';
+this.loadShard(MyShard);
+
+// Código transformado (build)
+const MyShard = '../surface/shards/MyShard.mjs';
+this.loadShard(MyShard);  // Ahora recibe la URL del archivo
+```
+
+---
+
+## 7. Comunicación con Engine
+
+### 7.1 Notificación de Estado
+
+Los Shards notifican automáticamente al Engine sus cambios de estado:
+
+```ts
+// Interno - se ejecuta automáticamente
+notifyShardState(status: ShardStatusType, error?: any)
+```
+
+Esto dispara un evento `shard:state-change` que el Engine puede escuchar.
+
+### 7.2 Decorador @onShard
+
+El Engine usa `@onShard` para reaccionar a cambios del Shard:
+
+```ts
+import { onShard } from '@extensio/core';
+import { ShardStatus } from '@extensio/core';
+
+class MyEngine extends Engine {
+  @onShard('my-shard', ShardStatus.Mounted)
+  onShardReady(state: ShardState) {
+    // El shard está montado y listo
+  }
+
+  @onShard('my-shard', ShardStatus.Error)
+  onShardError(state: ShardState) {
+    this.error('Shard failed:', state.error);
+  }
+}
+```
+
+### 7.3 ShardState
+
+| Campo | Tipo | Descripción |
+|-------|------|-------------|
+| `shardId` | `string` | ID del Shard |
+| `url` | `string` | URL donde está montado |
+| `tabId` | `number` | ID del tab |
+| `documentId` | `string?` | ID del documento |
+| `status` | `ShardStatusType` | Estado actual |
+| `error` | `Error?` | Error si aplica |
+| `timestamp` | `number` | Timestamp del evento |
+
+---
+
+## 8. Responsabilidades (SRP)
+
+Un Shard tiene **tres responsabilidades únicas**:
+
+### 8.1 Reactividad
+- Recibir propiedades mediante `@property`
+- Reaccionar a cambios mediante `@onChanged`
+- Actualizar su estado interno
+
+### 8.2 Acciones
+- Responder a eventos del usuario (clicks, inputs)
+- Emitir eventos al Engine/Page
+- Delegar decisiones de negocio al orquestador
+
+### 8.3 Renderizado
+- Mostrar estado visual
+- Actualizar la UI cuando cambian las props
+- Gestionar estilos y animaciones
+
+---
+
+## 9. Restricciones
+
+Un Shard **NO DEBE**:
+
+| Restricción | Razón |
+|-------------|-------|
+| Contener lógica de negocio | Page o Engine son los orquestadores |
+| Almacenar estado persistente | El estado vive en Engine |
+| Tomar decisiones de dominio | Solo renderiza y emite eventos |
+| Acceder directamente a drivers | Comunicarse via Engine |
+| Modificar estado global | Solo su propio estado de UI |
+
+### Principio Fundamental
+
+> **"Un Shard es un componente de UI puro: recibe estado, lo renderiza, y emite eventos."**
+
+---
+
+## 10. Build y CLI
+
+### 10.1 Detección de Shards
+
+El CLI detecta Shards mediante:
+1. Registro en `src/surface/shards/index.mts`
+2. Uso de `loadShard()` en el Engine
+3. Imports que contengan `/shards/` en el path
+
+### 10.2 Compilación Independiente
+
+Cada Shard se compila como módulo ES independiente (`.mjs`):
+- Permite carga dinámica en content scripts
+- Evita bundlear el Shard con el Engine
+- Facilita inyección via `Scripting.executeScript()`
+
+### 10.3 Output
+
+```
+dist/
+└── surface/
+    └── shards/
+        ├── my-shard.mjs      # Shard compilado
+        └── another-shard.mjs
+```
+
+---
+
+## 11. Adaptadores (Ejemplos - No Oficiales)
+
+> **NOTA**: Los siguientes adaptadores son ejemplos no consolidados como oficiales.
+
+### LitShard
+Adaptador para usar Lit como sistema de renderizado.
+
+### ReactShard
+Adaptador para usar React como sistema de renderizado.
+
+Estos adaptadores están en desarrollo y no deben considerarse como el patrón oficial todavía.
+
+---
+
+## 12. Auditoría
+
+Criterios mínimos de auditoría para un Shard:
+
+| Criterio | Verificación |
+|----------|--------------|
+| Estructura | Conforme a §3 |
+| Hereda de Shard | `class X extends Shard` |
+| Registrado | `Shard.register()` en índice |
+| Métodos abstractos | `_mount()`, `_unmount()`, `update()`, `getTagName()` |
+| Sin lógica de negocio | Conforme a §8-9 |
+| Tag único | kebab-case con prefijo de módulo |
+
+---
+
+## 13. Severidad
+
+Cualquier violación de:
+- Estructura (§3)
+- Ciclo de vida (§4)
+- Responsabilidades (§8-9)
+
+se considera **SEVERITY: HIGH** y bloquea la validación del Shard.
+
+---