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

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

@@ -51,6 +51,12 @@ Führt Claude in einer kontinuierlichen Schleife aus, bis die Aufgabe abgeschlos
    - Maximale Iterationen, Timeouts, DoD-Kriterien festlegen
    - Hooks initialisieren, falls aktiviert
 
+#### Isolierung von Sessions und parallelen Workern
+
+- **Explizite Claude-Session**: Jede Ralph-Session legt ihre eigene Claude-Konversations-ID fest — `claude --session-id <uuid>` in der ersten Iteration, danach `claude --resume <uuid>`. Die UUID wird in `.ralph/sessions/<session>/claude_session_id` gespeichert, sodass `--continue=<session>` die richtige Konversation fortsetzt. Ralph verwendet `claude --continue` nicht mehr, das „die neueste Konversation im Verzeichnis“ fortsetzte (geteilt zwischen Workern oder sogar mit der interaktiven Session des Benutzers).
+- **Ein Git-Worktree pro Worker** (paralleler Modus, `lib/parallel-manager.sh`): Jede Story läuft in einem eigenen Worktree `.ralph/parallel/worktrees/<session>` auf dem Branch `ralph/<session>`, mit ihrem Ralph-Zustand unter `.ralph/parallel/sessions/<session>/ralph/`. Am Ende des Laufs werden verbleibende Änderungen als `wip(ralph): <story>` auf diesem Branch committet, danach wird der Worktree entfernt (`git worktree remove`). Schlägt dieser Commit fehl, bleibt der Worktree erhalten (kein Datenverlust) und wird in `output.log` gemeldet. Die Arbeit wird durch Mergen der `ralph/*`-Branches übernommen.
+- **Außerhalb eines Git-Repositorys**: kein Worktree; der Worker läuft im aktuellen Verzeichnis (eine Warnung wird ausgegeben), die Isolierung der Claude-Sessions bleibt bestehen.
+
 ### 2. Hauptschleife mit Dashboard
 
 ```

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

@@ -51,6 +51,12 @@ Execute Claude in a continuous loop until the task is complete or the Definition
    - Set max iterations, timeouts, DoD criteria
    - Initialize hooks if enabled
 
+#### Session and parallel worker isolation
+
+- **Explicit Claude session**: each Ralph session pins its own Claude conversation ID — `claude --session-id <uuid>` on the first iteration, then `claude --resume <uuid>`. The UUID is stored in `.ralph/sessions/<session>/claude_session_id`, so `--continue=<session>` resumes the right conversation. Ralph no longer uses `claude --continue`, which resumed "the most recent conversation in the directory" (shared between workers, or even with the user's interactive session).
+- **One git worktree per worker** (parallel mode, `lib/parallel-manager.sh`): each story runs in a dedicated worktree `.ralph/parallel/worktrees/<session>` on branch `ralph/<session>`, with its Ralph state under `.ralph/parallel/sessions/<session>/ralph/`. At the end of the run, leftover changes are committed as `wip(ralph): <story>` on that branch, then the worktree is removed (`git worktree remove`). If that commit fails, the worktree is kept (no data loss) and reported in `output.log`. Collect the work by merging the `ralph/*` branches.
+- **Outside a git repository**: no worktree; the worker runs in the current directory (a warning is printed), Claude session isolation still applies.
+
 ### 2. Main Loop with Dashboard
 
 ```

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

@@ -51,6 +51,12 @@ Ejecuta Claude en un bucle continuo hasta que la tarea esté completa o se cumpl
    - Establecer máximo de iteraciones, timeouts y criterios DoD
    - Inicializar hooks si están habilitados
 
+#### Aislamiento de sesiones y workers paralelos
+
+- **Sesión de Claude explícita**: cada sesión de Ralph fija su propio identificador de conversación de Claude — `claude --session-id <uuid>` en la primera iteración y luego `claude --resume <uuid>`. El UUID se guarda en `.ralph/sessions/<session>/claude_session_id`, de modo que `--continue=<session>` reanuda la conversación correcta. Ralph ya no usa `claude --continue`, que reanudaba «la conversación más reciente del directorio» (compartida entre workers, o incluso con la sesión interactiva del usuario).
+- **Un worktree de git por worker** (modo paralelo, `lib/parallel-manager.sh`): cada historia se ejecuta en un worktree dedicado `.ralph/parallel/worktrees/<session>` sobre la rama `ralph/<session>`, con su estado de Ralph en `.ralph/parallel/sessions/<session>/ralph/`. Al final de la ejecución, los cambios pendientes se confirman como `wip(ralph): <story>` en esa rama y después se elimina el worktree (`git worktree remove`). Si ese commit falla, el worktree se conserva (sin pérdida de datos) y se indica en `output.log`. El trabajo se recupera fusionando las ramas `ralph/*`.
+- **Fuera de un repositorio git**: sin worktree; el worker se ejecuta en el directorio actual (se muestra un aviso) y el aislamiento de sesiones de Claude se mantiene.
+
 ### 2. Bucle Principal con Dashboard
 
 ```

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

@@ -51,6 +51,12 @@ Exécuter Claude en boucle continue jusqu'à ce que la tâche soit terminée ou
    - Définir les itérations max, les timeouts, les critères DoD
    - Initialiser les hooks si activés
 
+#### Isolation des sessions et des workers parallèles
+
+- **Session Claude explicite** : chaque session Ralph fixe son propre identifiant de conversation Claude — `claude --session-id <uuid>` à la première itération, puis `claude --resume <uuid>`. L'UUID est stocké dans `.ralph/sessions/<session>/claude_session_id`, ce qui permet à `--continue=<session>` de reprendre la bonne conversation. Ralph n'utilise plus `claude --continue`, qui reprenait « la conversation la plus récente du répertoire » (partagée entre workers, voire avec une session interactive de l'utilisateur).
+- **Worktree git par worker** (mode parallèle, `lib/parallel-manager.sh`) : chaque story s'exécute dans un worktree dédié `.ralph/parallel/worktrees/<session>` sur la branche `ralph/<session>`, avec son état Ralph sous `.ralph/parallel/sessions/<session>/ralph/`. En fin de run, les modifications restantes sont commitées en `wip(ralph): <story>` sur cette branche, puis le worktree est retiré (`git worktree remove`). Si ce commit échoue, le worktree est conservé (aucune perte) et signalé dans `output.log`. Le travail se récupère en fusionnant les branches `ralph/*`.
+- **Hors dépôt git** : pas de worktree ; le worker s'exécute dans le répertoire courant (avertissement affiché), l'isolation des sessions Claude restant assurée.
+
 ### 2. Boucle principale avec Dashboard
 
 ```

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

@@ -51,6 +51,12 @@ Executa o Claude em loop contínuo até que a tarefa seja concluída ou os crit
    - Definir máximo de iterações, timeouts e critérios de DoD
    - Inicializar hooks se habilitados
 
+#### Isolamento de sessões e workers paralelos
+
+- **Sessão Claude explícita**: cada sessão Ralph fixa seu próprio identificador de conversa Claude — `claude --session-id <uuid>` na primeira iteração e depois `claude --resume <uuid>`. O UUID é armazenado em `.ralph/sessions/<session>/claude_session_id`, para que `--continue=<session>` retome a conversa correta. O Ralph não usa mais `claude --continue`, que retomava "a conversa mais recente do diretório" (compartilhada entre workers, ou até com a sessão interativa do usuário).
+- **Um worktree git por worker** (modo paralelo, `lib/parallel-manager.sh`): cada história é executada em um worktree dedicado `.ralph/parallel/worktrees/<session>` na branch `ralph/<session>`, com seu estado Ralph em `.ralph/parallel/sessions/<session>/ralph/`. No fim da execução, as alterações restantes são commitadas como `wip(ralph): <story>` nessa branch e o worktree é removido (`git worktree remove`). Se esse commit falhar, o worktree é mantido (sem perda de dados) e sinalizado em `output.log`. O trabalho é recuperado fazendo merge das branches `ralph/*`.
+- **Fora de um repositório git**: sem worktree; o worker é executado no diretório atual (um aviso é exibido) e o isolamento das sessões Claude continua garantido.
+
 ### 2. Loop Principal com Painel
 
 ```

package/Dev/scripts/install-common-rules.sh

@@ -465,6 +465,14 @@ install_commands() {
     done
     IFS="$OLD_IFS"
 
+    # The deprecated common:pre-commit-check|pre-merge-check|release-checklist
+    # stubs redirect to /gate:check, which otherwise ships only with the Project
+    # package: install it here too so a Dev-only install keeps them working.
+    local gate_check="$SCRIPT_DIR/../../Project/i18n/$lang/Gate/commands/check.md"
+    if [[ -f "$gate_check" ]]; then
+        copy_file "$gate_check" "$target_dir/.claude/commands/gate/check.md"
+    fi
+
     # Delete commands retired from the distribution (config/removed-commands.yaml)
     $dry_run || bash "$SCRIPT_DIR/prune-removed-commands.sh" "$target_dir"
 

package/README.md

@@ -26,7 +26,7 @@ Plus **11 stack-specific reviewers** (@symfony-reviewer, @react-reviewer, @pytho
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Mutation testing badge](https://img.shields.io/endpoint?style=flat&url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2FTheBeardedBearSAS%2Fclaude-craft%2Fmain)](https://dashboard.stryker-mutator.io/reports/github.com/TheBeardedBearSAS/claude-craft/main)
 
-A comprehensive framework for AI-assisted development with [Claude Code](https://claude.ai/code). Install standardized rules, agents, and commands for your projects across multiple technology stacks — **33 specialized agents (+39 infra agents on-demand), 139 commands across 17 namespaces (238 total, including deprecated redirect stubs kept until 9.0), 55 skills**, all token-optimized via `context: fork` and sub-agent model routing.
+A comprehensive framework for AI-assisted development with [Claude Code](https://claude.ai/code). Install standardized rules, agents, and commands for your projects across multiple technology stacks — **33 specialized agents (+39 infra agents on-demand), 140 commands across 18 namespaces (238 total, including deprecated redirect stubs kept until 9.0), 55 skills**, all token-optimized via `context: fork` and sub-agent model routing.
 
 ## What's New in v8.26.0
 
@@ -187,7 +187,7 @@ Claude Code is powerful on its own. Claude Craft makes it **consistent and team-
 
 - **Standardized rules** -- SOLID, Clean Architecture, TDD enforced across your team, not just suggested
 - **33 default agents + 39 infra agents on-demand** -- reviewers, architects, coaches that know your stack deeply (72 total potentially installable)
-- **139 slash commands across 17 namespaces** -- repeatable workflows for audits, code generation, sprint management
+- **140 slash commands across 18 namespaces** -- repeatable workflows for audits, code generation, sprint management
 - **Quality gates** -- automated checks at every stage from PRD to deployment
 - **5 languages** -- English, French, Spanish, German, Portuguese
 

package/Tools/Ralph/lib/checkpoint.sh

@@ -207,12 +207,12 @@ list_checkpoints() {
 
     # Find commits matching the checkpoint pattern
     local commits
-    commits=$(git log --oneline --grep="checkpoint: Ralph" 2>/dev/null | head -20)
+    commits=$(git log --oneline --grep="checkpoint: Ralph" 2>/dev/null | head -20) || true
 
     if [[ -n "$commits" ]]; then
         echo "$commits" | while read -r line; do
-            local hash=$(echo "$line" | cut -d' ' -f1)
-            local msg=$(echo "$line" | cut -d' ' -f2-)
+            local hash=$(echo "$line" | cut -d' ' -f1) || true
+            local msg=$(echo "$line" | cut -d' ' -f2-) || true
             echo "{\"hash\":\"$hash\",\"message\":\"$msg\"}"
         done | jq -s '.'
     else

package/Tools/Ralph/lib/circuit-breaker.sh

@@ -30,35 +30,35 @@ CB_LEARNING_MIN_SAMPLES=5
 # =============================================================================
 # Each profile defines thresholds optimized for different task types
 
-declare -A CB_PROFILE_QUICK_FIX=(
+declare -gA CB_PROFILE_QUICK_FIX=(
     ["no_changes"]=2
     ["errors"]=3
     ["max_iterations"]=10
     ["keywords"]="fix bug typo hotfix patch"
 )
 
-declare -A CB_PROFILE_SMALL_FEATURE=(
+declare -gA CB_PROFILE_SMALL_FEATURE=(
     ["no_changes"]=3
     ["errors"]=4
     ["max_iterations"]=15
     ["keywords"]="add implement small simple"
 )
 
-declare -A CB_PROFILE_MEDIUM_FEATURE=(
+declare -gA CB_PROFILE_MEDIUM_FEATURE=(
     ["no_changes"]=4
     ["errors"]=6
     ["max_iterations"]=25
     ["keywords"]="feature create with tests"
 )
 
-declare -A CB_PROFILE_LARGE_FEATURE=(
+declare -gA CB_PROFILE_LARGE_FEATURE=(
     ["no_changes"]=5
     ["errors"]=8
     ["max_iterations"]=50
     ["keywords"]="refactor migrate complex large"
 )
 
-declare -A CB_PROFILE_EXPLORATION=(
+declare -gA CB_PROFILE_EXPLORATION=(
     ["no_changes"]=10
     ["errors"]=15
     ["max_iterations"]=100
@@ -66,7 +66,7 @@ declare -A CB_PROFILE_EXPLORATION=(
 )
 
 # Autonomous profile for overnight/unattended runs
-declare -A CB_PROFILE_AUTONOMOUS=(
+declare -gA CB_PROFILE_AUTONOMOUS=(
     ["no_changes"]=5
     ["errors"]=8
     ["max_iterations"]=50
@@ -162,7 +162,7 @@ init_circuit_breaker() {
 detect_task_profile() {
     local prompt="$1"
     local prompt_lower
-    prompt_lower=$(echo "$prompt" | tr '[:upper:]' '[:lower:]')
+    prompt_lower=$(echo "$prompt" | tr '[:upper:]' '[:lower:]') || true
 
     # Check each profile's keywords
     local profiles=("quick_fix" "small_feature" "medium_feature" "large_feature" "exploration" "autonomous")
@@ -265,7 +265,7 @@ apply_learned_adjustments() {
     ' "$history_file" 2>/dev/null)
 
     local samples
-    samples=$(echo "$profile_data" | jq -r '.samples // 0')
+    samples=$(echo "$profile_data" | jq -r '.samples // 0') || samples=0
 
     if [[ $samples -lt $CB_LEARNING_MIN_SAMPLES ]]; then
         print_verbose "Not enough samples for learning ($samples < $CB_LEARNING_MIN_SAMPLES)"
@@ -274,10 +274,10 @@ apply_learned_adjustments() {
 
     # Apply adjustments based on historical success rate
     local success_rate
-    success_rate=$(echo "$profile_data" | jq -r '.success_rate // 0')
+    success_rate=$(echo "$profile_data" | jq -r '.success_rate // 0') || success_rate=0
 
     local avg_iterations
-    avg_iterations=$(echo "$profile_data" | jq -r '.avg_iterations // 0')
+    avg_iterations=$(echo "$profile_data" | jq -r '.avg_iterations // 0') || avg_iterations=0
 
     # If success rate is low, increase thresholds
     if [[ $success_rate -lt 50 ]]; then

package/Tools/Ralph/lib/context-manager.sh

@@ -32,6 +32,9 @@ IFS=' ' read -r -a CLAUDE_CMD <<< "$CLAUDE_COMMAND"
 CONTEXT_COMPACT_COUNT=0
 CONTEXT_CONTINUATION_COUNT=0
 CONTEXT_CONTINUATION_PROMPT=""
+# Set by run_auto_compact (return 3) / handle_max_compacts_reached: call them
+# in this shell, never in `$(...)`, or the counters above are lost.
+CONTEXT_NEW_SESSION_ID=""
 
 # =============================================================================
 # Context Limit Detection
@@ -106,6 +109,17 @@ init_context_manager() {
     print_verbose "  - Smart reconstruction: $CONTEXT_SMART_RECONSTRUCTION"
 }
 
+# Print the first lines of `/context` for a Claude session UUID.
+# Best effort: prints nothing on failure, always succeeds (set -e safe).
+probe_context_usage() {
+    local claude_uuid="$1"
+    if command -v timeout &> /dev/null; then
+        timeout 10s "${CLAUDE_CMD[@]}" --resume "$claude_uuid" -p "/context" 2>/dev/null | head -5 || true
+    else
+        "${CLAUDE_CMD[@]}" --resume "$claude_uuid" -p "/context" 2>/dev/null | head -5 || true
+    fi
+}
+
 # =============================================================================
 # Auto-Compact
 # =============================================================================
@@ -120,20 +134,27 @@ run_auto_compact() {
         return 1
     fi
 
+    # /context and /compact must target this Ralph session's Claude session,
+    # never "the most recent conversation in this directory" (--continue).
+    local claude_uuid
+    claude_uuid=$(get_claude_session_uuid "$session_id")
+    if [[ -z "$claude_uuid" ]]; then
+        log_session "$session_id" "WARN" "No Claude session yet, nothing to compact"
+        return 1
+    fi
+
     # Check if context is above minimum threshold before compacting
     if [[ "$CONTEXT_MIN_THRESHOLD" -gt 0 ]]; then
         local context_info
-        if command -v timeout &> /dev/null; then
-            context_info=$(timeout 10s "${CLAUDE_CMD[@]}" -p "/context" 2>/dev/null | head -5)
-        else
-            context_info=$("${CLAUDE_CMD[@]}" -p "/context" 2>/dev/null | head -5)
-        fi
+        context_info=$(probe_context_usage "$claude_uuid")
         local current_usage
-        current_usage=$(echo "$context_info" | grep -oP '\d+(?=%)' | head -1)
+        current_usage=$(echo "$context_info" | grep -oP '\d+(?=%)' | head -1 || true)
 
         if [[ -n "$current_usage" && "$current_usage" -lt "$CONTEXT_MIN_THRESHOLD" ]]; then
             log_session "$session_id" "INFO" "Context at ${current_usage}% - below minimum threshold (${CONTEXT_MIN_THRESHOLD}%), skipping compact"
-            print_verbose "Context at ${current_usage}% - below min threshold (${CONTEXT_MIN_THRESHOLD}%), skipping compact"
+            local msg="${MSG_CONTEXT_BELOW_MIN:-"Context at {0}% - below minimum threshold ({1}%), skipping compact"}"
+            msg="${msg//\{0\}/"$current_usage"}"
+            print_verbose "${msg//\{1\}/"$CONTEXT_MIN_THRESHOLD"}"
             return 1
         fi
     fi
@@ -144,13 +165,12 @@ run_auto_compact() {
         print_warning "${MSG_CONTEXT_MAX_REACHED:-Maximum compacts reached} ($CONTEXT_MAX_COMPACTS)"
 
         # Handle overflow strategy
-        local overflow_result
-        overflow_result=$(handle_max_compacts_reached "$session_id")
-        local overflow_status=$?
+        local overflow_status=0
+        CONTEXT_NEW_SESSION_ID=""
+        handle_max_compacts_reached "$session_id" || overflow_status=$?
 
-        if [[ $overflow_status -eq 0 && -n "$overflow_result" ]]; then
-            # New session ID returned - signal continuation
-            echo "$overflow_result"
+        if [[ $overflow_status -eq 0 && -n "$CONTEXT_NEW_SESSION_ID" ]]; then
+            # New session ID in CONTEXT_NEW_SESSION_ID - signal continuation
             return 3  # Special return code for session continuation
         fi
 
@@ -185,11 +205,10 @@ run_auto_compact() {
 
     # Execute /compact via Claude CLI
     local compact_output
-    local compact_status
+    local compact_status=0
 
     if command -v timeout &> /dev/null; then
-        compact_output=$(timeout 60s "${CLAUDE_CMD[@]}" --continue -p "/compact" 2>&1)
-        compact_status=$?
+        compact_output=$(timeout 60s "${CLAUDE_CMD[@]}" --resume "$claude_uuid" -p "/compact" 2>&1) || compact_status=$?
 
         # Handle timeout specifically (exit code 124)
         if [[ $compact_status -eq 124 ]]; then
@@ -198,8 +217,7 @@ run_auto_compact() {
             return 1
         fi
     else
-        compact_output=$("${CLAUDE_CMD[@]}" --continue -p "/compact" 2>&1)
-        compact_status=$?
+        compact_output=$("${CLAUDE_CMD[@]}" --resume "$claude_uuid" -p "/compact" 2>&1) || compact_status=$?
     fi
 
     if [[ $compact_status -eq 0 ]]; then
@@ -313,10 +331,12 @@ handle_max_compacts_reached() {
             new_session_id=$(create_continuation_session "$session_id")
 
             if [[ -n "$new_session_id" ]]; then
+                # Reset here: create_continuation_session ran in a subshell
+                CONTEXT_COMPACT_COUNT=0
                 CONTEXT_CONTINUATION_COUNT=$((CONTEXT_CONTINUATION_COUNT + 1))
                 print_success "${MSG_CONTEXT_CONTINUATION_CREATED:-Continuation session created}: $new_session_id"
                 log_session "$session_id" "INFO" "Created continuation session: $new_session_id"
-                echo "$new_session_id"
+                CONTEXT_NEW_SESSION_ID="$new_session_id"
                 return 0
             else
                 print_error "Failed to create continuation session"
@@ -349,30 +369,11 @@ handle_max_compacts_reached() {
 create_continuation_session() {
     local previous_session="$1"
 
-    # Generate new session ID with portable random suffix generation
-    local timestamp=$(date +%Y%m%d_%H%M%S)
-    local random_suffix
-
-    # Use utils function if available, otherwise fallback
-    if type generate_random_suffix &>/dev/null; then
-        random_suffix=$(generate_random_suffix 4)
-    elif command -v xxd &>/dev/null; then
-        random_suffix=$(head -c 4 /dev/urandom | xxd -p)
-    elif command -v od &>/dev/null; then
-        random_suffix=$(head -c 4 /dev/urandom | od -An -tx1 | tr -d ' \n')
-    else
-        # Fallback: use $RANDOM (less entropy but portable)
-        random_suffix=$(printf '%04x%04x' $RANDOM $RANDOM | head -c 8)
-    fi
-
-    local new_session_id="ralph-cont-${timestamp}-${random_suffix}"
-
-    # Create session directory if create_session is available
-    if type create_session &>/dev/null; then
-        if ! create_session "$new_session_id" 2>/dev/null; then
-            print_warning "Failed to create session directory for $new_session_id"
-        fi
-    fi
+    # create_session takes a prompt and prints the id it created (with its
+    # state.json and session.log): the id must come from it, or the session
+    # directory is an orphan and the continuation id has no state.
+    local new_session_id
+    new_session_id=$(create_session "Continuation of $previous_session") || return 1
 
     # Link sessions in state files (with error handling)
     if type update_session_state &>/dev/null; then
@@ -385,10 +386,6 @@ create_continuation_session() {
         link_session_to_progress "$new_session_id" || print_verbose "Failed to link session to progress"
     fi
 
-    # Reset context manager for new session
-    CONTEXT_COMPACT_COUNT=0
-    CONTEXT_CONTINUATION_COUNT=$((CONTEXT_CONTINUATION_COUNT))  # Keep continuation count
-
     echo "$new_session_id"
 }
 
@@ -404,26 +401,28 @@ check_preventive_compact() {
         return 1
     fi
 
+    # Nothing to measure before the first Claude call of this session.
+    local claude_uuid
+    claude_uuid=$(get_claude_session_uuid "$session_id")
+    [[ -z "$claude_uuid" ]] && return 1
+
     # Try to get context usage from Claude CLI
     # Note: This is a best-effort check, Claude may not always report usage
     local context_info
-    if command -v timeout &> /dev/null; then
-        context_info=$(timeout 10s "${CLAUDE_CMD[@]}" -p "/context" 2>/dev/null | head -5)
-    else
-        context_info=$("${CLAUDE_CMD[@]}" -p "/context" 2>/dev/null | head -5)
-    fi
+    context_info=$(probe_context_usage "$claude_uuid")
 
     # Try to extract percentage from output
     local usage
-    usage=$(echo "$context_info" | grep -oP '\d+(?=%)' | head -1)
+    usage=$(echo "$context_info" | grep -oP '\d+(?=%)' | head -1 || true)
 
     if [[ -n "$usage" && "$usage" -ge "$CONTEXT_PREVENTIVE_THRESHOLD" ]]; then
-        print_warning "${MSG_CONTEXT_PREVENTIVE:-Context at ${usage}% - running preventive compact}"
+        local msg="${MSG_CONTEXT_PREVENTIVE:-Context at ${usage}% - running preventive compact}"
+        print_warning "${msg//\{0\}/$usage}"
         log_session "$session_id" "INFO" "Preventive compact triggered at ${usage}%"
 
         # Save progress before preventive compact
         if type save_sprint_progress &>/dev/null; then
-            save_sprint_progress "$session_id"
+            save_sprint_progress "$session_id" || print_verbose "No sprint progress file to save"
         fi
 
         run_auto_compact "$session_id"
@@ -437,23 +436,15 @@ check_preventive_compact() {
 # Context Continuation Prompt
 # =============================================================================
 
+# Print the continuation prompt stored by a real compaction, if any.
+# Callers using `$(...)` must reset CONTEXT_CONTINUATION_PROMPT themselves.
 get_context_continuation_prompt() {
-    # Return the stored continuation prompt if available
     if [[ -n "$CONTEXT_CONTINUATION_PROMPT" ]]; then
         echo "$CONTEXT_CONTINUATION_PROMPT"
-        # Clear after use
         CONTEXT_CONTINUATION_PROMPT=""
         return 0
     fi
 
-    # Generate fresh if smart reconstruction is enabled
-    if [[ "$CONTEXT_SMART_RECONSTRUCTION" == "true" ]]; then
-        if type generate_continuation_prompt &>/dev/null; then
-            generate_continuation_prompt
-            return 0
-        fi
-    fi
-
     return 1
 }