elsabro 2.1.0 → 2.3.0

package/skills/tutor.md

@@ -0,0 +1,219 @@
+---
+name: tutor
+description: Modo tutor socratico - aprendizaje guiado con tecnicas de Feynman y analisis de errores
+trigger: /elsabro:tutor
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Task
+argument-hint: "[tema] - tema a aprender (ej: useEffect, async/await, React hooks)"
+---
+
+# ELSABRO: Socratic Tutor
+
+<objective>
+Activar modo de aprendizaje socratico. En lugar de dar respuestas directamente,
+guiar al usuario a descubrir las respuestas por si mismo mediante preguntas
+estrategicas y tecnicas de refuerzo.
+</objective>
+
+<task_integration>
+## Integracion con Tasks API
+
+Al iniciar sesion de tutoria, crear tarea para tracking:
+
+```
+TaskCreate:
+  description: "Sesion de tutoria: [tema]"
+  status: in_progress
+```
+
+Actualizar progreso con checkpoints de confianza del usuario.
+Al finalizar sesion, marcar como completada con resumen de aprendizaje.
+</task_integration>
+
+<core_rules>
+## Reglas Fundamentales (OBLIGATORIAS)
+
+1. **NUNCA dar la respuesta inmediatamente** - Hacer que el usuario trabaje por ella
+2. **Explicar paso a paso SOLO cuando lo pida** - No sobre-explicar
+3. **Hacer preguntas estilo Socratico** - Para que piense y descubra
+4. **Quiz frecuente** - Mezclar multiple choice, respuesta corta, y "explicame esto"
+5. **Cuando se equivoque** - Mostrar el gap suavemente y pedir que intente de nuevo
+6. **Rating de confianza** - Pedir que califique su confianza (1-10) despues de cada tema
+</core_rules>
+
+<techniques>
+## Tecnicas Avanzadas
+
+### Feynman Checks
+Pedir que explique conceptos como si fuera principiante:
+
+```
+"Antes de continuar, explicame [concepto] como si yo nunca hubiera programado"
+```
+
+Esto revela si realmente entiende vs. pattern matching superficial.
+
+### Make Connections
+Vincular conceptos nuevos con conocimiento previo:
+
+```
+"Como se relaciona esto con [X que vimos antes]?"
+"En que se parece/diferencia de [concepto similar]?"
+```
+
+### Predict Before Reveal
+Antes de mostrar como funciona algo:
+
+```
+"Que crees que va a pasar cuando ejecutemos esto?"
+"Por que crees que funciona de esa manera?"
+```
+
+### Error Analysis
+Cuando cometa un error, no solo corregir:
+
+```
+"Interesante respuesta. Por que pensaste eso?"
+"Que te llevo a esa conclusion?"
+"Puedes identificar donde se desvio tu razonamiento?"
+```
+
+### Summarization Checkpoints
+Periodicamente pedir resumenes:
+
+```
+"Pausa. Resume lo que hemos aprendido hasta ahora en tus propias palabras."
+"Si tuvieras que explicar esto en un tweet, que dirias?"
+```
+
+### Spaced Callbacks
+Volver a conceptos anteriores inesperadamente:
+
+```
+"Por cierto, recuerdas lo que vimos sobre [tema anterior]? Como aplicaria aqui?"
+```
+</techniques>
+
+<session_flow>
+## Flujo de Sesion
+
+### Inicio
+```
+Usuario: /elsabro:tutor useEffect
+
+Claude: [Crea tarea de tutoria en Tasks]
+
+"Vamos a explorar useEffect. Antes de profundizar, respondeme:
+
+1. Que CREES que hace useEffect? No busques, dime lo que piensas.
+2. En que situaciones lo has usado o visto usado?
+
+Cuando tengas respuestas, continuamos."
+```
+
+### Durante
+```
+- Preguntas guiadas (no respuestas)
+- Checkpoints de confianza cada 2-3 conceptos
+- Feynman checks cuando el usuario "cree entender"
+- Error analysis sin juicio cuando falla
+```
+
+### Cierre
+```
+Claude: "Antes de terminar:
+
+1. Resume en 2-3 oraciones que aprendiste hoy sobre [tema]
+2. Como calificarias tu confianza ahora (1-10)?
+3. Que pregunta te queda pendiente?
+
+[Actualiza tarea con resumen de sesion]"
+```
+</session_flow>
+
+<example_flow>
+## Ejemplo de Flujo Completo
+
+```
+Usuario: /elsabro:tutor useEffect
+
+Claude: "Vamos a explorar useEffect. Antes de profundizar, respondeme:
+        Que CREES que hace useEffect? No busques, dime lo que piensas."
+
+Usuario: "Creo que ejecuta codigo cuando el componente se monta"
+
+Claude: "Casi. Solo cuando se monta? Que pasa si cambio una variable de estado?"
+
+Usuario: "Hmm... se vuelve a ejecutar?"
+
+Claude: "Correcto. Ahora, CUANDO se vuelve a ejecutar exactamente?
+        Pista: tiene que ver con el segundo argumento."
+
+[continua guiando con preguntas...]
+
+Claude: "Checkpoint de confianza: Como calificarias tu entendimiento
+        sobre cuando se ejecuta useEffect? (1-10)"
+
+Usuario: "Un 6"
+
+Claude: "Ok, sigamos practicando hasta que llegues a 8+.
+        Ahora, explicame el array de dependencias como si yo fuera
+        alguien que nunca ha usado React..."
+```
+</example_flow>
+
+<confidence_tracking>
+## Tracking de Confianza
+
+Mantener registro durante la sesion:
+
+| Concepto | Confianza Inicial | Confianza Final |
+|----------|-------------------|-----------------|
+| useEffect basico | 4 | 7 |
+| Dependencies array | 2 | 8 |
+| Cleanup function | 1 | 6 |
+
+**Meta**: Todos los conceptos en 7+ antes de cerrar sesion.
+</confidence_tracking>
+
+<exit_modes>
+## Salir del Modo Tutor
+
+El usuario puede salir diciendo:
+- "Salir de modo tutor"
+- "Ya entendi, continua normal"
+- `/elsabro:tutor off`
+- "Modo normal"
+
+Al salir, guardar resumen en la tarea y marcar como completada.
+</exit_modes>
+
+<adaptation>
+## Adaptacion Dinamica
+
+- Si responde correctamente 3 veces seguidas: aumentar dificultad
+- Si falla 2 veces seguidas: dar pistas mas directas
+- Si confianza < 5: volver a lo basico
+- Si confianza > 8: introducir edge cases y complejidad
+- Si usuario frustrado: ofrecer explicacion directa como opcion
+</adaptation>
+
+<integration_memory>
+## Integracion con Memoria ELSABRO
+
+Al detectar gaps de conocimiento recurrentes:
+
+```
+"He notado que [concepto X] te cuesta. Quieres que agregue
+ejercicios de repaso a tu proxima sesion?"
+```
+
+Guardar en `.planning/notes/learning.md`:
+- Temas dominados
+- Temas que necesitan refuerzo
+- Progreso historico
+</integration_memory>

package/templates/CLAUDE.md.template

@@ -0,0 +1,48 @@
+# [NOMBRE_PROYECTO] - Memoria de Claude
+
+## Stack Tecnologico
+<!-- Descomenta y personaliza segun tu proyecto -->
+<!-- - Frontend: React/Next.js/Vue -->
+<!-- - Backend: Node/Python/Go -->
+<!-- - Database: PostgreSQL/MongoDB -->
+<!-- - Deploy: Vercel/AWS/Docker -->
+
+## Reglas de Codigo (OBLIGATORIAS)
+
+### Estilo
+- Preferir TypeScript sobre JavaScript
+- Componentes funcionales con hooks
+- Imports especificos, no `import *`
+- Async/await sobre .then()
+
+### Patrones
+- Composicion sobre herencia
+- Funciones puras cuando sea posible
+- Early returns para reducir anidamiento
+- Error handling explicito
+
+### Naming
+- camelCase para variables y funciones
+- PascalCase para componentes y clases
+- SCREAMING_SNAKE para constantes
+- Nombres descriptivos, no abreviados
+
+## NO HACER (Errores Aprendidos)
+
+**Ver archivo completo:** `.planning/mistakes.md`
+
+<!-- Errores criticos se documentan aqui como resumen -->
+
+## Contexto del Proyecto
+
+### Arquitectura
+<!-- Describir arquitectura de alto nivel -->
+
+### Decisiones Importantes
+<!-- Documentar decisiones arquitectonicas y por que -->
+
+## Referencias
+
+- Errores detallados: `.planning/mistakes.md`
+- Patrones preferidos: `.planning/patterns.md`
+- Notas por feature: `.planning/notes/`

package/templates/error-handling-config.json

@@ -70,12 +70,14 @@
       }
     },
     "continue_all": {
-      "description": "Continúa siempre, reporta fallos al final",
+      "description": "Continúa siempre si al menos 1 agente tiene éxito, reporta fallos al final",
       "useWhen": "Todos los agentes son independientes",
       "behavior": {
         "onFirstFailure": "continue",
         "waitForRunning": true,
-        "successThreshold": 0
+        "successThreshold": 0,
+        "minSuccessCount": 1,
+        "abortOnTotalFailure": true
       }
     },
     "critical_path": {
@@ -134,5 +136,80 @@
       "severity": "HIGH",
       "suggestedAction": "Reintentar o verificar conectividad"
     }
+  },
+
+  "contracts": {
+    "registryValidator": {
+      "enabled": true,
+      "fallbacksEnabled": true,
+      "cacheTimeMs": 300000
+    },
+    "taskLifecycle": {
+      "enabled": true,
+      "validStates": ["INIT", "ACTIVE", "COMPLETE", "FAILED", "ROLLED_BACK", "DELETED"],
+      "validTransitions": {
+        "INIT": ["ACTIVE", "FAILED", "DELETED"],
+        "ACTIVE": ["COMPLETE", "FAILED", "ROLLED_BACK"],
+        "COMPLETE": ["ROLLED_BACK"],
+        "FAILED": ["ACTIVE", "DELETED"],
+        "ROLLED_BACK": ["INIT"],
+        "DELETED": []
+      }
+    },
+    "timeoutHandler": {
+      "enabled": true,
+      "defaultTimeoutMs": 1800000,
+      "healthCheckIntervalMs": 5000,
+      "warningThresholds": [80, 95],
+      "maxExtensions": 2
+    },
+    "retryPolicy": {
+      "enabled": true,
+      "maxAttempts": 3,
+      "baseDelayMs": 1000,
+      "maxDelayMs": 10000,
+      "backoffMultiplier": 2,
+      "timeoutPerAttemptMs": 30000,
+      "totalTimeoutMs": 120000,
+      "retryablePatterns": [
+        "timeout|ETIMEDOUT",
+        "ECONNREFUSED|ENOTFOUND",
+        "temporary|transient",
+        "503|429",
+        "network|connection"
+      ]
+    },
+    "errorAggregator": {
+      "enabled": true,
+      "defaultPolicy": "quorum",
+      "policies": {
+        "fail_fast": { "successThreshold": 1.0, "waitForAll": false },
+        "quorum": { "successThreshold": 0.5, "waitForAll": true },
+        "continue_all": { "successThreshold": 0.0, "waitForAll": true },
+        "critical_path": { "successThreshold": null, "waitForAll": true }
+      }
+    },
+    "severityClassifier": {
+      "enabled": true,
+      "patterns": {
+        "CRITICAL": ["state.*missing", "corrupted", "CONFLICT", "permission.*denied"],
+        "HIGH": ["test.*fail", "build.*fail", "timeout", "api.*error"],
+        "MEDIUM": ["lint.*warning", "deprecat", "coverage.*low"],
+        "LOW": ["info", "log", "note"]
+      }
+    },
+    "sessionValidator": {
+      "enabled": true,
+      "requiredFields": ["version", "createdAt", "status", "context.milestone"],
+      "stalenessWarningDays": 7,
+      "stalenessErrorDays": 30,
+      "healthCheckIntervalMs": 30000
+    }
+  },
+
+  "notificationSettings": {
+    "immediateNotification": ["CRITICAL"],
+    "summaryAtEnd": ["HIGH", "MEDIUM", "LOW"],
+    "displayFormat": "ascii_box"
   }
 }

package/templates/mistakes.md.template

@@ -0,0 +1,52 @@
+# Errores Corregidos
+
+> Este archivo contiene errores que Claude ha cometido y NO debe repetir.
+> Claude lee este archivo automaticamente al iniciar cada sesion.
+
+## Como Agregar Errores
+
+Cuando corrijas a Claude, di:
+- "No, hazlo asi..."
+- "Siempre usa X en lugar de Y"
+- "Guarda esto en tu memoria"
+
+Claude detectara la correccion y la agregara aqui automaticamente.
+
+---
+
+## TypeScript / Tipos
+
+<!-- Errores de tipado -->
+
+## Imports / Modulos
+
+<!-- Errores de imports -->
+
+## React / Hooks
+
+<!-- Errores de React -->
+
+## API / Backend
+
+<!-- Errores de backend -->
+
+## Testing
+
+<!-- Errores en tests -->
+
+## Git / Workflow
+
+<!-- Errores de git -->
+
+---
+
+## Estadisticas
+
+| Categoria | Errores | Ultima Actualizacion |
+|-----------|---------|---------------------|
+| TypeScript | 0 | - |
+| Imports | 0 | - |
+| React | 0 | - |
+| API | 0 | - |
+| Testing | 0 | - |
+| Git | 0 | - |

package/templates/patterns.md.template

@@ -0,0 +1,114 @@
+# Patrones Preferidos
+
+> Este archivo contiene patrones de codigo que el proyecto prefiere.
+> Claude usa estos patrones como referencia al escribir codigo nuevo.
+
+## Componentes React
+
+```tsx
+// Estructura preferida de componente
+interface Props {
+  // Props tipadas
+}
+
+export function ComponentName({ prop1, prop2 }: Props) {
+  // Hooks primero
+  const [state, setState] = useState<Type>(initial);
+
+  // Efectos despues
+  useEffect(() => {
+    // ...
+  }, [deps]);
+
+  // Handlers
+  const handleClick = () => {
+    // ...
+  };
+
+  // Early returns para casos edge
+  if (!data) return <Loading />;
+
+  // Render principal
+  return (
+    <div>
+      {/* ... */}
+    </div>
+  );
+}
+```
+
+## Custom Hooks
+
+```tsx
+// Estructura preferida de hook
+export function useCustomHook(param: Type) {
+  const [state, setState] = useState<Type>(initial);
+
+  useEffect(() => {
+    // Efecto
+    return () => {
+      // Cleanup
+    };
+  }, [param]);
+
+  return { state, actions };
+}
+```
+
+## API Calls
+
+```tsx
+// Patron preferido para fetch
+async function fetchData<T>(url: string): Promise<T> {
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+```
+
+## Error Handling
+
+```tsx
+// Patron preferido para errores
+try {
+  const result = await riskyOperation();
+  return { success: true, data: result };
+} catch (error) {
+  console.error('[Context]:', error);
+  return { success: false, error: error.message };
+}
+```
+
+## Testing
+
+```tsx
+// Estructura preferida de test
+describe('ComponentName', () => {
+  it('should render correctly', () => {
+    render(<ComponentName />);
+    expect(screen.getByRole('button')).toBeInTheDocument();
+  });
+
+  it('should handle user interaction', async () => {
+    const user = userEvent.setup();
+    render(<ComponentName />);
+
+    await user.click(screen.getByRole('button'));
+
+    expect(/* resultado */).toBe(/* esperado */);
+  });
+});
+```
+
+---
+
+## Como Agregar Patrones
+
+Cuando quieras que Claude use un patron especifico, di:
+- "Siempre usa este patron para..."
+- "Prefiero que los componentes se vean asi..."
+- "Guarda este patron en tu memoria"