@the-bearded-bear/claude-craft 4.4.0 → 5.0.0-next.fa2403f

package/Dev/i18n/de/Common/commands/ralph-sprint.md

@@ -0,0 +1,159 @@
+---
+description: Autonomen Sprint-Conductor fur Overnight/unbeaufsichtigte Sprint-Ausfuhrung starten
+argument-hint: <sprint-name> [--overnight|--parallel N|--supervised|--max-stories N]
+---
+
+# Ralph Sprint - Autonomer Sprint Conductor (ASC)
+
+Fuhrt einen gesamten Sprint autonom mit minimaler menschlicher Intervention aus. Der Autonome Sprint Conductor (ASC) verwaltet Story-Claiming, Ausfuhrung, Ubergange, Fehlerwiederherstellung und Eskalation blockierender Probleme.
+
+## Argumente
+
+**$ARGUMENTS**
+
+- `<sprint-name>`: Name oder ID des zu verarbeitenden Sprints
+- `--overnight`: Overnight-Modus (begrenzt, stoppt um 6 Uhr)
+- `--parallel N`: Bis zu N Stories parallel verarbeiten (Standard: 1)
+- `--supervised`: Pause vor jeder Story zur Bestatigung
+- `--max-stories N`: Maximale Stories zu verarbeiten (Standard: 10)
+- `--timeout H`: Maximale Laufzeit in Stunden (Standard: 12)
+
+## Hauptfunktionen
+
+| Funktion | Beschreibung |
+|----------|--------------|
+| **Auto-Claim** | Beansprucht automatisch die nachste bereite Story |
+| **Auto-Transition** | Ubergangsgeschichten basierend auf Abschlussstatus |
+| **Recovery Engine** | Automatische Wiederherstellung von vorubergehenden/behebbaren Fehlern |
+| **Eskalationsdienst** | Warteschlange fur blockierende Probleme zur menschlichen Losung |
+| **Parallelverarbeitung** | Verarbeitet mehrere unabhangige Stories gleichzeitig |
+| **Begrenzte Ausfuhrung** | Zeitfenster, Story-Limits, Fehlerschwellen |
+
+## Prozess
+
+### 1. Sprint-Initialisierung
+
+1. **Sprint-Konfiguration laden**:
+   - Metadaten aus `.bmad/sprint-status.yaml` lesen
+   - Autonome Konfiguration aus `ralph-autonomous.yml` laden
+   - Recovery Engine und Eskalationsdienst initialisieren
+
+2. **Autonomen Modus aktivieren**:
+   - Circuit Breaker auf autonomes Profil setzen
+   - Wiederherstellung vor Auslosung aktivieren
+   - Parallel Manager initialisieren falls aktiviert
+
+### 2. Hauptschleife des Conductors
+
+Der ASC fuhrt eine kontinuierliche Schleife aus:
+
+1. Stoppbedingungen prufen
+2. Nachste bereite Story holen
+3. Story beanspruchen
+4. Mit Ralph ausfuhren
+5. Ergebnis verarbeiten (Erfolg/Fehler/Eskaliert)
+6. Story transitieren
+7. Checkpoint erstellen
+
+### 3. Fehlerwiederherstellung
+
+Die Recovery Engine klassifiziert Fehler in 4 Stufen:
+
+| Stufe | Typ | Aktion | Beispiele |
+|-------|-----|--------|-----------|
+| 0 | **Vorubergehend** | Auto-Retry mit Backoff | Timeout, Rate Limit, Netzwerk |
+| 1 | **Behebbar** | Auto-Fix + Retry | Lint, Tests, Deps, Syntax |
+| 2 | **Degradiert** | Fortsetzen mit Warnung | Docs, optionale Gates |
+| 3 | **Blockiert** | An Menschen eskalieren | Sicherheit, Architektur |
+
+### 4. Eskalationsmanagement
+
+Blockierende Probleme werden fur menschliche Losung in die Warteschlange gestellt.
+
+**Losungsoptionen**:
+- `proceed` - Mit der Aufgabe fortfahren
+- `skip` - Diese Story uberspringen und fortfahren
+- `retry` - Fehlgeschlagene Operation erneut versuchen
+- `abort` - Sprint stoppen
+
+### 5. Stoppbedingungen
+
+| Bedingung | Standard | Beschreibung |
+|-----------|----------|--------------|
+| Max Stories | 10 | Maximale verarbeitete Stories |
+| Max Fehler | 3 | Schwelle fur aufeinanderfolgende Fehler |
+| Max Laufzeit | 12h | Maximale Gesamtlaufzeit |
+| Stoppfenster | 06:00 | Zeitbasierter Stopp (Overnight) |
+| Kritische Eskalation | - | Pause bei kritischen Problemen |
+
+## Schnellstart-Beispiele
+
+```bash
+# Overnight-Sprint
+/common:ralph-sprint "Sprint 3" --overnight
+
+# Parallelverarbeitung mit 3 Sitzungen
+/common:ralph-sprint "Sprint 3" --parallel 3
+
+# Uberwachter Modus
+/common:ralph-sprint "Sprint 3" --supervised
+
+# Begrenzte Ausfuhrung
+/common:ralph-sprint "Sprint 3" --max-stories 5 --timeout 4
+```
+
+## Konfiguration
+
+Der ASC verwendet `Tools/Ralph/config/ralph-autonomous.yml`:
+
+```yaml
+autonomous:
+  enabled: true
+  mode: "bounded"
+  schedule:
+    stop_window: "06:00"
+    max_runtime_hours: 12
+  limits:
+    max_stories_per_session: 10
+    max_consecutive_failures: 3
+  parallel:
+    enabled: false
+    max_concurrent: 3
+
+recovery:
+  enabled: true
+  max_attempts: 3
+  auto_fix_lint: true
+  auto_fix_tests: "retry_tdd"
+
+escalation:
+  enabled: true
+  timeout_hours: 4
+  default_action: "skip"
+  critical_action: "pause"
+```
+
+## Erfolgsmetriken
+
+| Metrik | Aktuell | Ziel |
+|--------|---------|------|
+| Menschliche Eingriffe/Sprint | ~15 | <5 |
+| Overnight abgeschlossene Stories | 0 | 3-5 |
+| Auto-Wiederherstellungsrate | N/A | >70% |
+| Zeit bis Eskalation | N/A | <15 min |
+| Parallelisierungseffizienz | N/A | >60% |
+
+## Best Practices
+
+1. **Uberwacht beginnen**: Zuerst `--supervised` verwenden
+2. **Realistische Limits**: max-stories anfangs nicht zu hoch setzen
+3. **Eskalationen uberwachen**: `.ralph/escalations/queue/` regelmasig prufen
+4. **Metriken analysieren**: `metrics-*.json` nach jedem Lauf untersuchen
+5. **Webhooks konfigurieren**: Slack/Teams-Benachrichtigungen fur kritische Probleme
+
+## Verwandt
+
+- `/common:ralph-run` - Kontinuierliche Schleife fur eine Aufgabe
+- `/project:run-sprint` - Standard-Sprint-Ausfuhrung
+- `/sprint:next-story` - Nachste bereite Story holen
+- `@ralph-conductor` - Ralph-Orchestrierungsagent

package/Dev/i18n/en/Common/commands/ralph-sprint.md

@@ -0,0 +1,293 @@
+---
+description: Run autonomous sprint conductor for overnight/unattended sprint execution
+argument-hint: <sprint-name> [--overnight|--parallel N|--supervised|--max-stories N]
+---
+
+# Ralph Sprint - Autonomous Sprint Conductor (ASC)
+
+Execute an entire sprint autonomously with minimal human intervention. The Autonomous Sprint Conductor (ASC) manages story claiming, execution, transitions, recovery from errors, and escalation of blocking issues.
+
+## Arguments
+
+**$ARGUMENTS**
+
+- `<sprint-name>`: Name or ID of the sprint to process
+- `--overnight`: Run in overnight mode (bounded, stops at 6am)
+- `--parallel N`: Process up to N stories in parallel (default: 1)
+- `--supervised`: Pause before each story for confirmation
+- `--max-stories N`: Maximum stories to process (default: 10)
+- `--timeout H`: Maximum runtime in hours (default: 12)
+
+## Key Features
+
+| Feature | Description |
+|---------|-------------|
+| **Auto-Claim** | Automatically claims next ready-for-dev story |
+| **Auto-Transition** | Transitions stories based on completion state |
+| **Recovery Engine** | Auto-recovers from transient/recoverable errors |
+| **Escalation Service** | Queues blocking issues for human resolution |
+| **Parallel Processing** | Process multiple independent stories concurrently |
+| **Bounded Execution** | Time windows, story limits, failure thresholds |
+
+## Process
+
+### 1. Sprint Initialization
+
+1. **Load sprint configuration**:
+   - Read sprint metadata from `.bmad/sprint-status.yaml`
+   - Load autonomous config from `ralph-autonomous.yml`
+   - Initialize recovery engine and escalation service
+
+2. **Enable autonomous mode**:
+   - Set circuit breaker to autonomous profile
+   - Enable recovery before trip
+   - Initialize parallel manager if enabled
+
+### 2. Main Conductor Loop
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│              AUTONOMOUS SPRINT CONDUCTOR (ASC)                   │
+└───────────────────────────────┬─────────────────────────────────┘
+                                │
+    ┌───────────────────────────┼───────────────────────────────┐
+    ▼                           ▼                               ▼
+┌─────────┐              ┌─────────────┐               ┌─────────────┐
+│Get Next │──────────────│ Claim Story │───────────────│Execute with │
+│  Story  │              │             │               │    Ralph    │
+└────┬────┘              └─────────────┘               └──────┬──────┘
+     │                                                        │
+     │ No stories ──────────────────┐          ┌──────────────┘
+     ▼                              ▼          ▼
+┌─────────┐                  ┌─────────┐ ┌─────────┐
+│  Check  │                  │Finalize │ │Transition│
+│Escalate │                  │  Sprint │ │  Story   │
+└─────────┘                  └─────────┘ └─────────┘
+```
+
+### 3. Error Recovery
+
+The Recovery Engine classifies errors into 4 levels:
+
+| Level | Type | Action | Examples |
+|-------|------|--------|----------|
+| 0 | **Transient** | Auto-retry with backoff | Timeout, rate limit, network |
+| 1 | **Recoverable** | Auto-fix + retry | Lint, tests, deps, syntax |
+| 2 | **Degraded** | Continue with warning | Docs, optional gates, coverage |
+| 3 | **Blocked** | Escalate to human | Security, architecture, auth |
+
+### 4. Escalation Management
+
+Blocking issues are queued for human resolution:
+
+```yaml
+# .ralph/escalations/queue/ESC-xxx.yaml
+id: "ESC-1704067200-123"
+level: "blocked"
+error_type: "security"
+priority: "critical"
+timeout_at: "2024-01-02T10:00:00Z"
+default_action: "pause"
+```
+
+**Resolution options**:
+- `proceed` - Continue with the task
+- `skip` - Skip this story and continue
+- `retry` - Retry the failed operation
+- `abort` - Stop the sprint
+
+### 5. Stop Conditions
+
+The conductor stops when any condition is met:
+
+| Condition | Default | Description |
+|-----------|---------|-------------|
+| Max stories | 10 | Maximum stories processed |
+| Max failures | 3 | Consecutive failures threshold |
+| Max runtime | 12h | Maximum total runtime |
+| Stop window | 06:00 | Time-based stop (for overnight) |
+| Critical escalation | - | Pauses on critical issues |
+
+## Parallel Processing
+
+When `--parallel N` is specified, the ASC processes stories in parallel waves:
+
+### How It Works
+
+1. **Dependency Graph**: The ASC builds a dependency graph from `blocked_by` relationships
+2. **Wave Processing**: Stories are processed in waves based on dependency satisfaction
+3. **Slot Management**: Up to N concurrent sessions, limited by CPU/memory thresholds
+4. **Sequential Merge**: Git branches are merged sequentially to avoid conflicts
+
+```
+Wave 1: [US-001, US-002, US-003]  ← Independent stories (no blockers)
+           ↓        ↓        ↓
+        Session  Session  Session
+           ↓        ↓        ↓
+        Complete Complete Complete
+
+Wave 2: [US-004, US-005]  ← Depend on US-001/US-002 (now done)
+           ↓        ↓
+        Session  Session
+           ↓        ↓
+        Complete Complete
+```
+
+### Dependency Handling
+
+Stories are only scheduled when their dependencies are satisfied:
+
+```yaml
+# sprint-status.yaml
+stories:
+  US-001:
+    status: ready-for-dev
+    blocked_by: []            # ✓ Can start immediately
+  US-002:
+    status: ready-for-dev
+    blocked_by: []            # ✓ Can start immediately
+  US-003:
+    status: ready-for-dev
+    blocked_by: [US-001]      # ✗ Waits for US-001 completion
+```
+
+### Resource Limits
+
+```yaml
+# ralph-autonomous.yml
+parallel:
+  enabled: true
+  max_concurrent: 3
+  resource_limits:
+    cpu_percent: 80      # Don't spawn if CPU > 80%
+    mem_percent: 80      # Don't spawn if memory > 80%
+```
+
+## Quick Start Examples
+
+```bash
+# Overnight sprint run
+/common:ralph-sprint "Sprint 3" --overnight
+
+# Parallel processing with 3 sessions
+/common:ralph-sprint "Sprint 3" --parallel 3
+
+# Combined: parallel overnight
+/common:ralph-sprint "Sprint 3" --parallel 3 --overnight
+
+# Supervised mode (confirm each story)
+/common:ralph-sprint "Sprint 3" --supervised
+
+# Limited run (5 stories, 4 hours)
+/common:ralph-sprint "Sprint 3" --max-stories 5 --timeout 4
+```
+
+## Configuration
+
+The ASC uses `Tools/Ralph/config/ralph-autonomous.yml`:
+
+```yaml
+autonomous:
+  enabled: true
+  mode: "bounded"
+  schedule:
+    stop_window: "06:00"
+    max_runtime_hours: 12
+  limits:
+    max_stories_per_session: 10
+    max_consecutive_failures: 3
+  parallel:
+    enabled: false
+    max_concurrent: 3
+
+recovery:
+  enabled: true
+  max_attempts: 3
+  auto_retry_transient: true
+  auto_fix_lint: true
+  auto_fix_tests: "retry_tdd"
+
+escalation:
+  enabled: true
+  timeout_hours: 4
+  default_action: "skip"
+  critical_action: "pause"
+  webhook:
+    url: ""
+    type: "slack"
+```
+
+## Output
+
+```
+╔════════════════════════════════════════════════════════════╗
+║     Autonomous Sprint Conductor (ASC)                       ║
+║     Sprint 3                                                ║
+╚════════════════════════════════════════════════════════════╝
+
+ℹ [ASC] Initialized Sprint Conductor
+ℹ [ASC]   Session: ASC-20240101-120000-12345
+ℹ [ASC]   Mode: bounded
+ℹ [ASC]   Max stories: 10
+ℹ [ASC]   Max runtime: 12h
+
+ℹ [ASC] Processing story: US-001
+ℹ [ASC] Claimed story: US-001
+ℹ [ASC] Spawning Ralph for story: US-001
+✓ [ASC] Story completed: US-001
+ℹ [ASC] Transitioned US-001 to review
+
+ℹ [ASC] Processing story: US-002
+⚠ Error classified as Level 1 (recoverable): test_fail
+ℹ Attempting auto-fix for: test_fail
+ℹ TDD retry: extracting failing tests...
+✓ [ASC] Story completed: US-002
+
+ℹ [ASC] Processing story: US-003
+⚠ Error classified as Level 3 (blocked): security
+⚠ Escalation created: ESC-1704067200-123 (blocked - security)
+ℹ [ASC] Story escalated: US-003
+
+════════════════════════════════════════
+    Sprint Conductor Summary
+════════════════════════════════════════
+
+Session: ASC-20240101-120000-12345
+Duration: 4h 23m
+
+Stories:
+  Completed: 7
+  Failed:    1
+  Skipped:   2
+
+Escalations:
+  created: 3
+  resolved: 2
+
+Recovery attempts: 8
+```
+
+## Success Metrics
+
+| Metric | Current | Target |
+|--------|---------|--------|
+| Human interventions/sprint | ~15 | <5 |
+| Stories completed overnight | 0 | 3-5 |
+| Auto-recovery success rate | N/A | >70% |
+| Time to escalation | N/A | <15 min |
+| Parallel efficiency | N/A | >60% |
+
+## Best Practices
+
+1. **Start supervised**: Use `--supervised` first to validate behavior
+2. **Set realistic limits**: Don't set max-stories too high initially
+3. **Monitor escalations**: Check `.ralph/escalations/queue/` regularly
+4. **Review metrics**: Analyze `metrics-*.json` after each run
+5. **Configure webhooks**: Set up Slack/Teams notifications for critical issues
+
+## Related
+
+- `/common:ralph-run` - Single task continuous loop
+- `/project:run-sprint` - Standard sprint execution
+- `/sprint:next-story` - Get next ready story
+- `@ralph-conductor` - Ralph orchestration agent

package/Dev/i18n/es/Common/commands/ralph-sprint.md

@@ -0,0 +1,159 @@
+---
+description: Ejecutar el conductor de sprint autonomo para ejecucion overnight/desatendida
+argument-hint: <nombre-sprint> [--overnight|--parallel N|--supervised|--max-stories N]
+---
+
+# Ralph Sprint - Conductor de Sprint Autonomo (ASC)
+
+Ejecuta un sprint completo de forma autonoma con minima intervencion humana. El Conductor de Sprint Autonomo (ASC) gestiona la reclamacion de historias, ejecucion, transiciones, recuperacion de errores y escalamiento de problemas bloqueantes.
+
+## Argumentos
+
+**$ARGUMENTS**
+
+- `<nombre-sprint>`: Nombre o ID del sprint a procesar
+- `--overnight`: Modo nocturno (limitado, para a las 6am)
+- `--parallel N`: Procesar hasta N historias en paralelo (defecto: 1)
+- `--supervised`: Pausar antes de cada historia para confirmacion
+- `--max-stories N`: Maximo de historias a procesar (defecto: 10)
+- `--timeout H`: Tiempo maximo de ejecucion en horas (defecto: 12)
+
+## Caracteristicas Principales
+
+| Caracteristica | Descripcion |
+|----------------|-------------|
+| **Auto-Claim** | Reclama automaticamente la siguiente historia lista |
+| **Auto-Transicion** | Transiciona historias segun estado de completitud |
+| **Motor de Recuperacion** | Auto-recuperacion de errores transitorios/recuperables |
+| **Servicio de Escalamiento** | Cola de problemas bloqueantes para resolucion humana |
+| **Procesamiento Paralelo** | Procesa multiples historias independientes simultaneamente |
+| **Ejecucion Limitada** | Ventanas de tiempo, limites de historias, umbrales de fallos |
+
+## Proceso
+
+### 1. Inicializacion del Sprint
+
+1. **Cargar configuracion del sprint**:
+   - Leer metadatos desde `.bmad/sprint-status.yaml`
+   - Cargar config autonoma desde `ralph-autonomous.yml`
+   - Inicializar motor de recuperacion y servicio de escalamiento
+
+2. **Activar modo autonomo**:
+   - Configurar circuit breaker en perfil autonomo
+   - Activar recuperacion antes de disparo
+   - Inicializar gestor paralelo si esta activado
+
+### 2. Bucle Principal del Conductor
+
+El ASC ejecuta un bucle continuo:
+
+1. Verificar condiciones de parada
+2. Obtener siguiente historia lista
+3. Reclamar la historia
+4. Ejecutar con Ralph
+5. Procesar resultado (exito/fallo/escalado)
+6. Transicionar historia
+7. Crear checkpoint
+
+### 3. Recuperacion de Errores
+
+El Motor de Recuperacion clasifica errores en 4 niveles:
+
+| Nivel | Tipo | Accion | Ejemplos |
+|-------|------|--------|----------|
+| 0 | **Transitorio** | Auto-retry con backoff | Timeout, rate limit, red |
+| 1 | **Recuperable** | Auto-fix + retry | Lint, tests, deps, sintaxis |
+| 2 | **Degradado** | Continuar con warning | Docs, gates opcionales |
+| 3 | **Bloqueado** | Escalar a humano | Seguridad, arquitectura |
+
+### 4. Gestion de Escalamientos
+
+Los problemas bloqueantes se ponen en cola para resolucion humana.
+
+**Opciones de resolucion**:
+- `proceed` - Continuar con la tarea
+- `skip` - Saltar esta historia y continuar
+- `retry` - Reintentar la operacion fallida
+- `abort` - Detener el sprint
+
+### 5. Condiciones de Parada
+
+| Condicion | Defecto | Descripcion |
+|-----------|---------|-------------|
+| Max historias | 10 | Maximo de historias procesadas |
+| Max fallos | 3 | Umbral de fallos consecutivos |
+| Max runtime | 12h | Tiempo maximo total |
+| Ventana parada | 06:00 | Parada por hora (overnight) |
+| Escalamiento critico | - | Pausa en problemas criticos |
+
+## Ejemplos Rapidos
+
+```bash
+# Sprint nocturno
+/common:ralph-sprint "Sprint 3" --overnight
+
+# Procesamiento paralelo con 3 sesiones
+/common:ralph-sprint "Sprint 3" --parallel 3
+
+# Modo supervisado
+/common:ralph-sprint "Sprint 3" --supervised
+
+# Ejecucion limitada
+/common:ralph-sprint "Sprint 3" --max-stories 5 --timeout 4
+```
+
+## Configuracion
+
+El ASC usa `Tools/Ralph/config/ralph-autonomous.yml`:
+
+```yaml
+autonomous:
+  enabled: true
+  mode: "bounded"
+  schedule:
+    stop_window: "06:00"
+    max_runtime_hours: 12
+  limits:
+    max_stories_per_session: 10
+    max_consecutive_failures: 3
+  parallel:
+    enabled: false
+    max_concurrent: 3
+
+recovery:
+  enabled: true
+  max_attempts: 3
+  auto_fix_lint: true
+  auto_fix_tests: "retry_tdd"
+
+escalation:
+  enabled: true
+  timeout_hours: 4
+  default_action: "skip"
+  critical_action: "pause"
+```
+
+## Metricas de Exito
+
+| Metrica | Actual | Objetivo |
+|---------|--------|----------|
+| Intervenciones humanas/sprint | ~15 | <5 |
+| Historias completadas overnight | 0 | 3-5 |
+| Tasa auto-recuperacion | N/A | >70% |
+| Tiempo hasta escalamiento | N/A | <15 min |
+| Eficiencia paralelizacion | N/A | >60% |
+
+## Mejores Practicas
+
+1. **Empezar supervisado**: Usar `--supervised` primero
+2. **Limites realistas**: No poner max-stories muy alto inicialmente
+3. **Monitorear escalamientos**: Revisar `.ralph/escalations/queue/`
+4. **Analizar metricas**: Examinar `metrics-*.json` despues de cada run
+5. **Configurar webhooks**: Notificaciones Slack/Teams para problemas criticos
+
+## Relacionado
+
+- `/common:ralph-run` - Bucle continuo para una tarea
+- `/project:run-sprint` - Ejecucion estandar de sprint
+- `/sprint:next-story` - Obtener siguiente historia lista
+- `@ralph-conductor` - Agente de orquestacion Ralph