@the-bearded-bear/claude-craft 8.26.0-next.2a54921 → 8.26.0

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

@@ -76,35 +76,6 @@ Das DoD-System validiert den Abschluss über mehrere Kriterien:
 | `hook` | Bestehenden Claude-Hook ausführen |
 | `human` | Interaktive menschliche Validierung |
 
-#### Grenze des `command`-Validators → `type: hook` verwenden
-
-`type: command` führt nur Befehle aus, die die Allowlist in `Tools/Ralph/lib/dod-validator.sh` bestehen: Buchstaben, Ziffern, Leerzeichen und `_ . / " ' -`. Jeder Befehl mit `=`, `|`, `&` oder `:` (sowie `;`, `>`, `$` usw.) wird mit `ERROR: Invalid command` abgelehnt: Das Kriterium wird dann **nie** erfüllt und die Schleife läuft, bis der Circuit Breaker auslöst.
-
-| Abgelehnter Befehl | Problematisches Zeichen |
-|--------------------|-------------------------|
-| `dotnet build /p:TreatWarningsAsErrors=true` | `:` und `=` |
-| `npm test && npm run lint` | `&` |
-| `pytest \| tee out.log` | `\|` |
-
-In diesen Fällen den Befehl in ein Skript auslagern und als `type: hook` deklarieren:
-
-```yaml
-definition_of_done:
-  checklist:
-    - id: build
-      type: hook
-      script: ".ralph/dod/build.sh"
-      required: true
-```
-
-```bash
-#!/usr/bin/env bash
-# .ralph/dod/build.sh — erhält {"cwd": ..., "output": ...} als JSON über stdin
-dotnet build /p:TreatWarningsAsErrors=true || exit 2
-```
-
-Das Skript gibt `0` (Kriterium erfüllt) oder `2` (Kriterium fehlgeschlagen) zurück. Gelesene Schlüssel je Typ: `command` → `command:`, `output_contains` und `file_changed` → `pattern:`, `hook` → `script:`, `human` → `prompt:`.
-
 ### 4. Adaptiver Circuit Breaker (v2.0)
 
 Wählt automatisch das Profil basierend auf Aufgaben-Schlüsselwörtern:
@@ -129,23 +100,6 @@ Claude arbeitet...
 Stop → stop-dod-gate.sh → Blockieren, wenn DoD nicht erfüllt (exit 2)
 ```
 
-## /goal (interaktiv) oder Ralph (autonom/CI)?
-
-`/goal` ist ein nativer Claude-Code-Befehl, der in einer Sitzung eingegeben wird: Er ist keine Option von `ralph.sh` — `ralph.sh` bietet dafür keine an und erzeugt nie ein `/goal`. Beide Werkzeuge ergänzen sich:
-
-| Kriterium | `/goal` (nativ) | Ralph (`ralph.sh`) |
-|-----------|-----------------|--------------------|
-| Abschlussprüfung | LLM-Urteil: Ein kleines, schnelles Modell bewertet nach jedem Zug, was in der Konversation sichtbar ist — es führt keinen Befehl aus und liest keine Datei | Deterministisch: Befehle, Muster und Hooks, ausgeführt von `dod-validator.sh` |
-| Iterationsobergrenze | Keine feste Grenze: Ende, wenn die Bedingung erfüllt oder als unmöglich bewertet ist, bei `/goal clear` oder wenn Claude mehrere Züge in Folge ohne Werkzeug antwortet; eine Grenze kann in die Bedingung geschrieben werden | `max_iterations` + adaptiver Circuit Breaker |
-| Headless / CI | `claude -p "/goal ..."` läuft in einem einzigen Aufruf bis zum Ende; CI-Nutzung nicht dokumentiert | Dafür gebaut: autonome Läufe (`--autonomous`, `--overnight`), `headless`-Dashboard |
-| `disableAllHooks: true` | Nicht verfügbar: `/goal` umhüllt einen sitzungsbezogenen Stop-Hook (ebenso mit `allowManagedHooksOnly`) | Schleife und DoD laufen in `ralph.sh`; nur die Hooks-Integration (`stop-dod-gate.sh`) ist deaktiviert |
-| Konfiguration | Keine; ein Goal pro Sitzung, durch `/clear` gelöscht | `ralph.yml` |
-
-- **`/goal` wählen** für eine interaktive Aufgabe, deren Abschluss in der Konversation sichtbar wird (Testausgabe anzeigen: Der Evaluator führt die Tests nicht aus).
-- **Ralph wählen**, wenn der Abschluss durch Befehle belegt werden muss, mit Iterationsobergrenze, unbeaufsichtigt oder in CI.
-
-Referenz: [`/goal`-Dokumentation](https://code.claude.com/docs/en/goal).
-
 ## Schnellstart-Beispiele
 
 ```bash

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

@@ -76,35 +76,6 @@ The DoD system validates completion through multiple criteria:
 | `hook` | Run existing Claude hook |
 | `human` | Interactive human validation |
 
-#### `command` validator limit → use `type: hook`
-
-`type: command` only runs commands that pass the allowlist in `Tools/Ralph/lib/dod-validator.sh`: letters, digits, space and `_ . / " ' -`. Any command containing `=`, `|`, `&` or `:` (as well as `;`, `>`, `$`, etc.) is rejected with `ERROR: Invalid command`: the criterion is then **never** met and the loop runs until the circuit breaker trips.
-
-| Rejected command | Offending character |
-|------------------|---------------------|
-| `dotnet build /p:TreatWarningsAsErrors=true` | `:` and `=` |
-| `npm test && npm run lint` | `&` |
-| `pytest \| tee out.log` | `\|` |
-
-For these cases, put the command in a script and declare it as `type: hook`:
-
-```yaml
-definition_of_done:
-  checklist:
-    - id: build
-      type: hook
-      script: ".ralph/dod/build.sh"
-      required: true
-```
-
-```bash
-#!/usr/bin/env bash
-# .ralph/dod/build.sh — receives {"cwd": ..., "output": ...} as JSON on stdin
-dotnet build /p:TreatWarningsAsErrors=true || exit 2
-```
-
-The script returns `0` (criterion met) or `2` (criterion failed). Keys read per type: `command` → `command:`, `output_contains` and `file_changed` → `pattern:`, `hook` → `script:`, `human` → `prompt:`.
-
 ### 4. Adaptive Circuit Breaker (v2.0)
 
 Automatically selects profile based on task keywords:
@@ -129,23 +100,6 @@ Claude works...
 Stop → stop-dod-gate.sh → Block if DoD not satisfied (exit 2)
 ```
 
-## /goal (interactive) or Ralph (autonomous/CI)?
-
-`/goal` is a native Claude Code command typed inside a session: it is not a `ralph.sh` option — `ralph.sh` has none for it and never generates a `/goal`. The two tools are complementary:
-
-| Criterion | `/goal` (native) | Ralph (`ralph.sh`) |
-|-----------|------------------|--------------------|
-| Completion check | LLM judgment: a small fast model evaluates, after each turn, what is visible in the conversation — it runs no command and reads no file | Deterministic: commands, patterns and hooks run by `dod-validator.sh` |
-| Iteration cap | No fixed cap: ends when the condition is met or judged impossible, on `/goal clear`, or if Claude answers several turns in a row without tools; a bound can be written into the condition | `max_iterations` + adaptive circuit breaker |
-| Headless / CI | `claude -p "/goal ..."` loops to completion in a single invocation; CI usage not documented | Built for it: autonomous runs (`--autonomous`, `--overnight`), `headless` dashboard |
-| `disableAllHooks: true` | Unavailable: `/goal` wraps a session-scoped Stop hook (same with `allowManagedHooksOnly`) | The loop and the DoD run inside `ralph.sh`; only the hooks integration (`stop-dod-gate.sh`) is disabled |
-| Configuration | None; one goal per session, cleared by `/clear` | `ralph.yml` |
-
-- **Choose `/goal`** for an interactive task whose completion shows up in the conversation (print the test output: the evaluator does not run it).
-- **Choose Ralph** when completion must be proven by commands, with an iteration cap, unattended or in CI.
-
-Reference: [`/goal` documentation](https://code.claude.com/docs/en/goal).
-
 ## Quick Start Examples
 
 ```bash

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

@@ -76,35 +76,6 @@ El sistema DoD valida la finalización a través de múltiples criterios:
 | `hook` | Ejecutar un hook de Claude existente |
 | `human` | Validación humana interactiva |
 
-#### Límite del validador `command` → usar `type: hook`
-
-`type: command` solo ejecuta los comandos que pasan la lista blanca de `Tools/Ralph/lib/dod-validator.sh`: letras, dígitos, espacio y `_ . / " ' -`. Cualquier comando que contenga `=`, `|`, `&` o `:` (así como `;`, `>`, `$`, etc.) se rechaza con `ERROR: Invalid command`: el criterio **nunca** se valida y el bucle se ejecuta hasta que salta el circuit breaker.
-
-| Comando rechazado | Carácter culpable |
-|-------------------|-------------------|
-| `dotnet build /p:TreatWarningsAsErrors=true` | `:` y `=` |
-| `npm test && npm run lint` | `&` |
-| `pytest \| tee out.log` | `\|` |
-
-En estos casos, colocar el comando en un script y declararlo como `type: hook`:
-
-```yaml
-definition_of_done:
-  checklist:
-    - id: build
-      type: hook
-      script: ".ralph/dod/build.sh"
-      required: true
-```
-
-```bash
-#!/usr/bin/env bash
-# .ralph/dod/build.sh — recibe {"cwd": ..., "output": ...} en JSON por stdin
-dotnet build /p:TreatWarningsAsErrors=true || exit 2
-```
-
-El script devuelve `0` (criterio cumplido) o `2` (criterio fallido). Claves leídas por tipo: `command` → `command:`, `output_contains` y `file_changed` → `pattern:`, `hook` → `script:`, `human` → `prompt:`.
-
 ### 4. Circuit Breaker Adaptativo (v2.0)
 
 Selecciona automáticamente el perfil basándose en palabras clave de la tarea:
@@ -129,23 +100,6 @@ Claude trabaja...
 Stop → stop-dod-gate.sh → Bloquear si DoD no satisfecho (exit 2)
 ```
 
-## ¿/goal (interactivo) o Ralph (autónomo/CI)?
-
-`/goal` es un comando nativo de Claude Code que se escribe dentro de una sesión: no es una opción de `ralph.sh`, que no ofrece ninguna para ello y nunca genera un `/goal`. Ambas herramientas son complementarias:
-
-| Criterio | `/goal` (nativo) | Ralph (`ralph.sh`) |
-|----------|------------------|--------------------|
-| Criterio de fin | Juicio LLM: un modelo pequeño y rápido evalúa, tras cada turno, lo que es visible en la conversación — no ejecuta ningún comando ni lee ningún archivo | Determinista: comandos, patrones y hooks ejecutados por `dod-validator.sh` |
-| Límite de iteraciones | Sin límite fijo: termina cuando la condición se cumple o se juzga imposible, con `/goal clear`, o si Claude encadena varios turnos sin herramientas; se puede escribir un límite en la condición | `max_iterations` + circuit breaker adaptativo |
-| Headless / CI | `claude -p "/goal ..."` itera hasta el final en una sola invocación; uso en CI no documentado | Diseñado para ello: ejecución autónoma (`--autonomous`, `--overnight`), dashboard `headless` |
-| `disableAllHooks: true` | No disponible: `/goal` envuelve un Stop hook de sesión (igual con `allowManagedHooksOnly`) | El bucle y la DoD se ejecutan dentro de `ralph.sh`; solo se desactiva la integración de hooks (`stop-dod-gate.sh`) |
-| Configuración | Ninguna; un único goal por sesión, borrado por `/clear` | `ralph.yml` |
-
-- **Elegir `/goal`** para una tarea interactiva cuyo fin se constata en la conversación (mostrar la salida de los tests: el evaluador no los ejecuta).
-- **Elegir Ralph** cuando el fin debe demostrarse con comandos, con un límite de iteraciones, de forma autónoma o en CI.
-
-Referencia: [documentación de `/goal`](https://code.claude.com/docs/en/goal).
-
 ## Ejemplos de Inicio Rápido
 
 ```bash

package/Dev/i18n/fr/Common/commands/ralph-run.md

@@ -76,35 +76,6 @@ Le système DoD valide la complétion à travers plusieurs critères :
 | `hook` | Exécuter un hook Claude existant |
 | `human` | Validation humaine interactive |
 
-#### Limite du validateur `command` → utiliser `type: hook`
-
-`type: command` n'exécute que les commandes qui passent la liste blanche de `Tools/Ralph/lib/dod-validator.sh` : lettres, chiffres, espace et `_ . / " ' -`. Toute commande contenant `=`, `|`, `&` ou `:` (ainsi que `;`, `>`, `$`, etc.) est rejetée avec `ERROR: Invalid command` : le critère n'est alors **jamais** validé et la boucle tourne jusqu'au circuit breaker.
-
-| Commande rejetée | Caractère en cause |
-|------------------|--------------------|
-| `dotnet build /p:TreatWarningsAsErrors=true` | `:` et `=` |
-| `npm test && npm run lint` | `&` |
-| `pytest \| tee out.log` | `\|` |
-
-Pour ces cas, placer la commande dans un script et la déclarer en `type: hook` :
-
-```yaml
-definition_of_done:
-  checklist:
-    - id: build
-      type: hook
-      script: ".ralph/dod/build.sh"
-      required: true
-```
-
-```bash
-#!/usr/bin/env bash
-# .ralph/dod/build.sh — reçoit {"cwd": ..., "output": ...} en JSON sur stdin
-dotnet build /p:TreatWarningsAsErrors=true || exit 2
-```
-
-Le script retourne `0` (critère validé) ou `2` (critère échoué). Clés lues par type : `command` → `command:`, `output_contains` et `file_changed` → `pattern:`, `hook` → `script:`, `human` → `prompt:`.
-
 ### 4. Circuit Breaker Adaptatif (v2.0)
 
 Sélection automatique du profil selon les mots-clés de la tâche :
@@ -129,23 +100,6 @@ Claude travaille...
 Stop → stop-dod-gate.sh → Bloquer si DoD non satisfait (exit 2)
 ```
 
-## /goal (interactif) ou Ralph (autonome/CI) ?
-
-`/goal` est une commande native de Claude Code, tapée dans une session : ce n'est pas une option de `ralph.sh`, qui n'en propose aucune et ne génère jamais de `/goal`. Les deux outils sont complémentaires :
-
-| Critère | `/goal` (natif) | Ralph (`ralph.sh`) |
-|---------|-----------------|--------------------|
-| Critère de fin | Jugement LLM : un petit modèle rapide évalue, après chaque tour, ce qui est visible dans la conversation — il ne lance aucune commande et ne lit aucun fichier | Déterministe : commandes, patterns et hooks exécutés par `dod-validator.sh` |
-| Plafond d'itérations | Aucun plafond fixe : fin quand la condition est atteinte ou jugée impossible, sur `/goal clear`, ou si Claude enchaîne plusieurs tours sans outil ; une borne peut être écrite dans la condition | `max_iterations` + circuit breaker adaptatif |
-| Headless / CI | `claude -p "/goal ..."` boucle jusqu'au bout en une seule invocation ; usage en CI non documenté | Conçu pour : exécution autonome (`--autonomous`, `--overnight`), dashboard `headless` |
-| `disableAllHooks: true` | Indisponible : `/goal` enveloppe un Stop hook de session (idem avec `allowManagedHooksOnly`) | La boucle et la DoD tournent dans `ralph.sh` ; seule l'intégration hooks (`stop-dod-gate.sh`) est désactivée |
-| Configuration | Aucune ; un seul goal par session, effacé par `/clear` | `ralph.yml` |
-
-- **Choisir `/goal`** pour une tâche interactive dont la fin se constate dans la conversation (afficher la sortie des tests : l'évaluateur ne les lance pas).
-- **Choisir Ralph** quand la fin doit être prouvée par des commandes, avec un plafond d'itérations, en autonomie ou en CI.
-
-Référence : [documentation `/goal`](https://code.claude.com/docs/en/goal).
-
 ## Exemples de démarrage rapide
 
 ```bash

package/Dev/i18n/pt/Common/commands/ralph-run.md

@@ -76,35 +76,6 @@ O sistema de DoD valida a conclusão por meio de múltiplos critérios:
 | `hook` | Executar hook existente do Claude |
 | `human` | Validação humana interativa |
 
-#### Limite do validador `command` → usar `type: hook`
-
-`type: command` só executa comandos que passam na lista de permissões de `Tools/Ralph/lib/dod-validator.sh`: letras, dígitos, espaço e `_ . / " ' -`. Qualquer comando contendo `=`, `|`, `&` ou `:` (assim como `;`, `>`, `$` etc.) é rejeitado com `ERROR: Invalid command`: o critério **nunca** é validado e o loop roda até o circuit breaker disparar.
-
-| Comando rejeitado | Caractere culpado |
-|-------------------|-------------------|
-| `dotnet build /p:TreatWarningsAsErrors=true` | `:` e `=` |
-| `npm test && npm run lint` | `&` |
-| `pytest \| tee out.log` | `\|` |
-
-Nesses casos, colocar o comando em um script e declará-lo como `type: hook`:
-
-```yaml
-definition_of_done:
-  checklist:
-    - id: build
-      type: hook
-      script: ".ralph/dod/build.sh"
-      required: true
-```
-
-```bash
-#!/usr/bin/env bash
-# .ralph/dod/build.sh — recebe {"cwd": ..., "output": ...} em JSON via stdin
-dotnet build /p:TreatWarningsAsErrors=true || exit 2
-```
-
-O script retorna `0` (critério atendido) ou `2` (critério falhou). Chaves lidas por tipo: `command` → `command:`, `output_contains` e `file_changed` → `pattern:`, `hook` → `script:`, `human` → `prompt:`.
-
 ### 4. Circuit Breaker Adaptativo (v2.0)
 
 Seleciona automaticamente o perfil com base nas palavras-chave da tarefa:
@@ -129,23 +100,6 @@ Claude trabalha...
 Stop → stop-dod-gate.sh → Bloquear se DoD não satisfeito (exit 2)
 ```
 
-## /goal (interativo) ou Ralph (autônomo/CI)?
-
-`/goal` é um comando nativo do Claude Code digitado dentro de uma sessão: não é uma opção de `ralph.sh`, que não oferece nenhuma para isso e nunca gera um `/goal`. As duas ferramentas são complementares:
-
-| Critério | `/goal` (nativo) | Ralph (`ralph.sh`) |
-|----------|------------------|--------------------|
-| Critério de conclusão | Julgamento LLM: um modelo pequeno e rápido avalia, após cada turno, o que está visível na conversa — não executa nenhum comando nem lê nenhum arquivo | Determinístico: comandos, padrões e hooks executados por `dod-validator.sh` |
-| Limite de iterações | Sem limite fixo: termina quando a condição é atendida ou julgada impossível, com `/goal clear`, ou se Claude encadeia vários turnos sem ferramentas; um limite pode ser escrito na condição | `max_iterations` + circuit breaker adaptativo |
-| Headless / CI | `claude -p "/goal ..."` itera até o fim em uma única invocação; uso em CI não documentado | Feito para isso: execução autônoma (`--autonomous`, `--overnight`), dashboard `headless` |
-| `disableAllHooks: true` | Indisponível: `/goal` envolve um Stop hook de sessão (idem com `allowManagedHooksOnly`) | O loop e a DoD rodam dentro de `ralph.sh`; só a integração de hooks (`stop-dod-gate.sh`) é desativada |
-| Configuração | Nenhuma; um único goal por sessão, apagado por `/clear` | `ralph.yml` |
-
-- **Escolher `/goal`** para uma tarefa interativa cuja conclusão aparece na conversa (exibir a saída dos testes: o avaliador não os executa).
-- **Escolher Ralph** quando a conclusão deve ser comprovada por comandos, com limite de iterações, sem supervisão ou em CI.
-
-Referência: [documentação do `/goal`](https://code.claude.com/docs/en/goal).
-
 ## Exemplos de Início Rápido
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-bearded-bear/claude-craft",
-  "version": "8.26.0-next.2a54921",
+  "version": "8.26.0",
   "description": "A comprehensive framework for AI-assisted development with Claude Code. Install standardized rules, agents, and commands for your projects.",
   "type": "module",
   "main": "cli/index.js",