@the-bearded-bear/claude-craft 8.26.0 → 8.27.0

package/Tools/Ralph/lib/sprint-conductor.sh

@@ -129,7 +129,7 @@ EOF
             PARALLEL_MAX_CONCURRENT="$ASC_PARALLEL_MAX"
             init_parallel_manager
         else
-            print_warning "Parallel manager not available, falling back to sequential"
+            print_warning "$(asc_msg MSG_ASC_NO_PARALLEL_MANAGER "Parallel manager not available, falling back to sequential")"
             ASC_PARALLEL_ENABLED="false"
         fi
     fi
@@ -139,14 +139,14 @@ EOF
         enable_autonomous_mode
     fi
 
-    log_conductor "Initialized Sprint Conductor"
-    log_conductor "  Session: $ASC_SESSION_ID"
-    log_conductor "  Mode: $ASC_MODE"
-    log_conductor "  Max stories: $ASC_MAX_STORIES"
-    log_conductor "  Max runtime: ${ASC_MAX_RUNTIME_HOURS}h"
-    log_conductor "  Parallel: $ASC_PARALLEL_ENABLED (max $ASC_PARALLEL_MAX)"
+    log_conductor "$(asc_msg MSG_ASC_INITIALIZED "Initialized Sprint Conductor")"
+    log_conductor "$(asc_msg MSG_ASC_INIT_SESSION "  Session: {0}" "$ASC_SESSION_ID")"
+    log_conductor "$(asc_msg MSG_ASC_INIT_MODE "  Mode: {0}" "$ASC_MODE")"
+    log_conductor "$(asc_msg MSG_ASC_INIT_MAX_STORIES "  Max stories: {0}" "$ASC_MAX_STORIES")"
+    log_conductor "$(asc_msg MSG_ASC_INIT_MAX_RUNTIME "  Max runtime: {0}h" "$ASC_MAX_RUNTIME_HOURS")"
+    log_conductor "$(asc_msg MSG_ASC_INIT_PARALLEL "  Parallel: {0} (max {1})" "$ASC_PARALLEL_ENABLED" "$ASC_PARALLEL_MAX")"
 
-    print_info "Sprint Conductor initialized: $ASC_SESSION_ID"
+    print_info "$(asc_msg MSG_ASC_INITIALIZED_ID "Sprint Conductor initialized: {0}" "$ASC_SESSION_ID")"
 }
 
 # =============================================================================
@@ -164,7 +164,7 @@ run_sprint_conductor() {
     [[ "$overnight" == "true" ]] && ASC_MODE="bounded"
     [[ "$supervised" == "true" ]] && ASC_MODE="supervised"
 
-    log_conductor "Starting sprint conductor for: $sprint_name (mode: $ASC_MODE)"
+    log_conductor "$(asc_msg MSG_ASC_STARTING "Starting sprint conductor for: {0} (mode: {1})" "$sprint_name" "$ASC_MODE")"
 
     # Use parallel or sequential execution based on configuration
     if [[ "$ASC_PARALLEL_ENABLED" == "true" ]] && type process_stories_parallel &>/dev/null; then
@@ -184,20 +184,20 @@ run_sprint_conductor() {
 run_sprint_conductor_parallel() {
     local sprint_name="$1"
 
-    log_conductor "Running in PARALLEL mode (max $ASC_PARALLEL_MAX concurrent)"
+    log_conductor "$(asc_msg MSG_ASC_PARALLEL_MODE "Running in PARALLEL mode (max {0} concurrent)" "$ASC_PARALLEL_MAX")"
 
     # Get all stories for the sprint
     local all_stories
     all_stories=$(get_all_ready_stories)
 
     if [[ -z "$all_stories" ]]; then
-        log_conductor "No stories available for parallel processing"
+        log_conductor "$(asc_msg MSG_ASC_NO_PARALLEL_STORIES "No stories available for parallel processing")"
         return 0
     fi
 
     local story_count
-    story_count=$(echo "$all_stories" | wc -w | tr -d ' ')
-    log_conductor "Found $story_count stories for parallel processing"
+    story_count=$(echo "$all_stories" | wc -l | tr -d ' ') || story_count=0
+    log_conductor "$(asc_msg MSG_ASC_FOUND_STORIES "Found {0} stories for parallel processing" "$story_count")"
 
     # Build dependency graph
     if type build_dependency_graph &>/dev/null; then
@@ -211,23 +211,17 @@ run_sprint_conductor_parallel() {
     while [[ $processed -lt $story_count ]]; do
         # Check stop conditions
         if ! check_continue_conditions; then
-            log_conductor "Stop condition met, halting parallel processing"
+            log_conductor "$(asc_msg MSG_ASC_STOP_PARALLEL "Stop condition met, halting parallel processing")"
             break
         fi
 
-        log_conductor "=== Wave $wave ==="
+        log_conductor "$(asc_msg MSG_ASC_WAVE "=== Wave {0} ===" "$wave")"
 
-        # Collect completed sessions from previous wave
+        # Collect completed sessions from previous wave (in this shell: it
+        # updates the tracking arrays that free the slots)
         if type collect_completed_sessions &>/dev/null; then
-            local completed_stories
-            completed_stories=$(collect_completed_sessions)
-
-            for story_id in $completed_stories; do
-                ASC_STORIES_COMPLETED=$((ASC_STORIES_COMPLETED + 1))
-                ASC_CONSECUTIVE_FAILURES=0
-                transition_story "$story_id" "review"
-                log_conductor "Story completed in parallel: $story_id"
-            done
+            collect_completed_sessions > /dev/null
+            process_collected_parallel_stories
         fi
 
         # Get stories ready for this wave (dependencies satisfied)
@@ -244,7 +238,7 @@ run_sprint_conductor_parallel() {
                 local active
                 active=$(get_active_count)
                 if [[ $active -gt 0 ]]; then
-                    log_conductor "Waiting for $active active sessions to complete..."
+                    log_conductor "$(asc_msg MSG_ASC_WAITING_ACTIVE "Waiting for {0} active sessions to complete..." "$active")"
                     sleep 10
                     continue
                 fi
@@ -257,7 +251,7 @@ run_sprint_conductor_parallel() {
             fi
 
             if [[ $pending_escalations -gt 0 ]]; then
-                log_conductor "Waiting for $pending_escalations pending escalations..."
+                log_conductor "$(asc_msg MSG_ASC_WAITING_ESCALATIONS "Waiting for {0} pending escalations..." "$pending_escalations")"
                 sleep 60
                 continue
             fi
@@ -274,9 +268,13 @@ run_sprint_conductor_parallel() {
             slots=$ASC_PARALLEL_MAX
         fi
 
-        # Spawn sessions for ready stories (up to available slots)
+        # Spawn sessions for ready stories (up to available slots), one id
+        # per line: ids may contain spaces
         local spawned=0
-        for story_id in $ready_stories; do
+        local -a ready_list=()
+        mapfile -t ready_list <<< "$ready_stories"
+        for story_id in "${ready_list[@]}"; do
+            [[ -z "$story_id" ]] && continue
             [[ $spawned -ge $slots ]] && break
 
             # Skip if already processed or in progress
@@ -287,16 +285,16 @@ run_sprint_conductor_parallel() {
             # Supervised mode - pause for confirmation
             if [[ "$ASC_MODE" == "supervised" ]]; then
                 if ! confirm_story_start "$story_id"; then
-                    log_conductor "Story skipped by user: $story_id"
+                    log_conductor "$(asc_msg MSG_ASC_SKIPPED_BY_USER "Story skipped by user: {0}" "$story_id")"
                     ASC_STORIES_SKIPPED=$((ASC_STORIES_SKIPPED + 1))
-                    ((processed++))
+                    processed=$((processed + 1))
                     continue
                 fi
             fi
 
             # Claim the story
             if ! claim_story "$story_id"; then
-                log_conductor "Failed to claim story: $story_id (may be claimed by another process)"
+                log_conductor "$(asc_msg MSG_ASC_CLAIM_FAILED_OTHER "Failed to claim story: {0} (may be claimed by another process)" "$story_id")"
                 continue
             fi
 
@@ -304,23 +302,26 @@ run_sprint_conductor_parallel() {
             local prompt
             prompt=$(build_story_prompt "$story_id")
 
-            # Spawn parallel session
+            # Spawn parallel session. Not in `$(...)`: the background worker
+            # would keep the substitution open until it ends (no parallelism).
             if type spawn_session &>/dev/null; then
-                local session_id
-                session_id=$(spawn_session "$story_id" "$prompt")
+                local session_id=""
+                if spawn_session "$story_id" "$prompt"; then
+                    session_id="$PARALLEL_SPAWNED_SESSION_ID"
+                fi
                 if [[ -n "$session_id" ]]; then
-                    log_conductor "Spawned parallel session $session_id for story $story_id"
-                    ((spawned++))
-                    ((processed++))
+                    log_conductor "$(asc_msg MSG_ASC_SPAWNED "Spawned parallel session {0} for story {1}" "$session_id" "$story_id")"
+                    spawned=$((spawned + 1))
+                    processed=$((processed + 1))
                 else
-                    log_conductor "Failed to spawn session for $story_id"
+                    log_conductor "$(asc_msg MSG_ASC_SPAWN_FAILED "Failed to spawn session for {0}" "$story_id")"
                     unclaim_story "$story_id"
                     ASC_STORIES_FAILED=$((ASC_STORIES_FAILED + 1))
                 fi
             else
                 # Fallback: execute sequentially
                 execute_story_with_ralph "$story_id"
-                ((processed++))
+                processed=$((processed + 1))
             fi
         done
 
@@ -331,7 +332,7 @@ run_sprint_conductor_parallel() {
         # Create checkpoint
         create_conductor_checkpoint
 
-        ((wave++))
+        wave=$((wave + 1))
 
         # Small delay between waves
         sleep 2
@@ -339,18 +340,13 @@ run_sprint_conductor_parallel() {
 
     # Wait for remaining sessions
     if type wait_all_sessions &>/dev/null; then
-        log_conductor "Waiting for all parallel sessions to complete..."
+        log_conductor "$(asc_msg MSG_ASC_WAITING_ALL "Waiting for all parallel sessions to complete...")"
         wait_all_sessions 0
 
-        # Final collection
+        # Final collection (wait_all_sessions already collected them)
         if type collect_completed_sessions &>/dev/null; then
-            local final_completed
-            final_completed=$(collect_completed_sessions)
-
-            for story_id in $final_completed; do
-                ASC_STORIES_COMPLETED=$((ASC_STORIES_COMPLETED + 1))
-                transition_story "$story_id" "review"
-            done
+            collect_completed_sessions > /dev/null
+            process_collected_parallel_stories
         fi
     fi
 
@@ -360,14 +356,42 @@ run_sprint_conductor_parallel() {
     fi
 }
 
+# Count and transition the stories collected from finished workers:
+# completed -> review, failed -> blocked (as in sequential mode).
+process_collected_parallel_stories() {
+    local -a completed_list=() failed_list=()
+    mapfile -t completed_list <<< "$PARALLEL_COLLECTED_STORIES"
+    mapfile -t failed_list <<< "$PARALLEL_FAILED_STORIES"
+    PARALLEL_COLLECTED_STORIES=""
+    PARALLEL_FAILED_STORIES=""
+
+    local story_id
+    for story_id in "${completed_list[@]}"; do
+        [[ -z "$story_id" ]] && continue
+        ASC_STORIES_COMPLETED=$((ASC_STORIES_COMPLETED + 1))
+        ASC_CONSECUTIVE_FAILURES=0
+        transition_story "$story_id" "review"
+        log_conductor "$(asc_msg MSG_ASC_PAR_COMPLETED "Story completed in parallel: {0}" "$story_id")"
+    done
+
+    for story_id in "${failed_list[@]}"; do
+        [[ -z "$story_id" ]] && continue
+        ASC_STORIES_FAILED=$((ASC_STORIES_FAILED + 1))
+        ASC_CONSECUTIVE_FAILURES=$((ASC_CONSECUTIVE_FAILURES + 1))
+        transition_story "$story_id" "blocked"
+        log_conductor "$(asc_msg MSG_ASC_PAR_FAILED "Story failed in parallel: {0}" "$story_id")"
+    done
+}
+
 # Check if a story is already in progress (parallel tracking)
 is_story_in_progress() {
     local story_id="$1"
 
-    # Check in parallel sessions
-    if [[ -n "${PARALLEL_SESSIONS[$story_id]:-}" ]]; then
-        return 0
-    fi
+    # Check in parallel sessions (keyed by session id, the value is the story)
+    local session_id
+    for session_id in "${!PARALLEL_SESSIONS[@]}"; do
+        [[ "${PARALLEL_SESSIONS[$session_id]}" == "$story_id" ]] && return 0
+    done
 
     # Check in BMAD status
     local bmad_dir="${BMAD_DIR:-.bmad}"
@@ -375,7 +399,7 @@ is_story_in_progress() {
 
     if [[ -f "$status_file" ]] && command -v yq &>/dev/null; then
         local status
-        status=$(yq ".stories.${story_id}.status" "$status_file" 2>/dev/null)
+        status=$(STORY_ID="$story_id" yq '.stories[strenv(STORY_ID)].status' "$status_file" 2>/dev/null)
         [[ "$status" == "in-progress" ]] && return 0
     fi
 
@@ -412,7 +436,7 @@ update_parallel_conductor_state() {
 run_sprint_conductor_sequential() {
     local sprint_name="$1"
 
-    log_conductor "Running in SEQUENTIAL mode"
+    log_conductor "$(asc_msg MSG_ASC_SEQUENTIAL_MODE "Running in SEQUENTIAL mode")"
 
     # Main loop
     while true; do
@@ -426,14 +450,14 @@ run_sprint_conductor_sequential() {
         next_story=$(get_next_ready_story)
 
         if [[ -z "$next_story" ]]; then
-            log_conductor "No more stories available"
+            log_conductor "$(asc_msg MSG_ASC_NO_MORE_STORIES "No more stories available")"
 
             # Check escalation queue
             if type get_pending_count &>/dev/null; then
                 local pending
                 pending=$(get_pending_count)
                 if [[ $pending -gt 0 ]]; then
-                    log_conductor "Waiting for $pending pending escalations..."
+                    log_conductor "$(asc_msg MSG_ASC_WAITING_ESCALATIONS "Waiting for {0} pending escalations..." "$pending")"
                     if type check_escalation_timeouts &>/dev/null; then
                         check_escalation_timeouts
                     fi
@@ -449,11 +473,11 @@ run_sprint_conductor_sequential() {
         ASC_CURRENT_STORY="$next_story"
         update_conductor_state "current" "$next_story"
 
-        log_conductor "Processing story: $next_story"
+        log_conductor "$(asc_msg MSG_ASC_PROCESSING "Processing story: {0}" "$next_story")"
 
         # Claim the story
         if ! claim_story "$next_story"; then
-            log_conductor "Failed to claim story: $next_story"
+            log_conductor "$(asc_msg MSG_ASC_CLAIM_FAILED "Failed to claim story: {0}" "$next_story")"
             ASC_STORIES_SKIPPED=$((ASC_STORIES_SKIPPED + 1))
             continue
         fi
@@ -461,7 +485,7 @@ run_sprint_conductor_sequential() {
         # Supervised mode - pause for confirmation
         if [[ "$ASC_MODE" == "supervised" ]]; then
             if ! confirm_story_start "$next_story"; then
-                log_conductor "Story skipped by user: $next_story"
+                log_conductor "$(asc_msg MSG_ASC_SKIPPED_BY_USER "Story skipped by user: {0}" "$next_story")"
                 unclaim_story "$next_story"
                 ASC_STORIES_SKIPPED=$((ASC_STORIES_SKIPPED + 1))
                 continue
@@ -469,34 +493,35 @@ run_sprint_conductor_sequential() {
         fi
 
         # Execute story with Ralph
+        # `|| status=$?`: a failed story must be counted, not kill the loop.
         local result
-        result=$(execute_story_with_ralph "$next_story")
-        local status=$?
+        local status=0
+        result=$(execute_story_with_ralph "$next_story") || status=$?
 
         # Process result
         case $status in
             0)
                 # Success
-                log_conductor "Story completed: $next_story"
+                log_conductor "$(asc_msg MSG_ASC_COMPLETED "Story completed: {0}" "$next_story")"
                 ASC_STORIES_COMPLETED=$((ASC_STORIES_COMPLETED + 1))
                 ASC_CONSECUTIVE_FAILURES=0
                 transition_story "$next_story" "review"
                 ;;
             1)
                 # Failed but recoverable
-                log_conductor "Story failed: $next_story"
+                log_conductor "$(asc_msg MSG_ASC_FAILED "Story failed: {0}" "$next_story")"
                 ASC_STORIES_FAILED=$((ASC_STORIES_FAILED + 1))
                 ASC_CONSECUTIVE_FAILURES=$((ASC_CONSECUTIVE_FAILURES + 1))
                 transition_story "$next_story" "blocked"
                 ;;
             2)
                 # Escalated
-                log_conductor "Story escalated: $next_story"
+                log_conductor "$(asc_msg MSG_ASC_ESCALATED "Story escalated: {0}" "$next_story")"
                 # Keep in-progress, will be handled by escalation resolution
                 ;;
             3)
                 # Skipped
-                log_conductor "Story skipped: $next_story"
+                log_conductor "$(asc_msg MSG_ASC_SKIPPED "Story skipped: {0}" "$next_story")"
                 ASC_STORIES_SKIPPED=$((ASC_STORIES_SKIPPED + 1))
                 transition_story "$next_story" "ready-for-dev"
                 ;;
@@ -521,13 +546,13 @@ check_continue_conditions() {
     # Check max stories
     local total_processed=$((ASC_STORIES_COMPLETED + ASC_STORIES_FAILED + ASC_STORIES_SKIPPED))
     if [[ $total_processed -ge $ASC_MAX_STORIES ]]; then
-        log_conductor "Max stories reached: $total_processed"
+        log_conductor "$(asc_msg MSG_ASC_MAX_STORIES "Max stories reached: {0}" "$total_processed")"
         return 1
     fi
 
     # Check consecutive failures
     if [[ $ASC_CONSECUTIVE_FAILURES -ge $ASC_MAX_CONSECUTIVE_FAILURES ]]; then
-        log_conductor "Max consecutive failures reached: $ASC_CONSECUTIVE_FAILURES"
+        log_conductor "$(asc_msg MSG_ASC_MAX_FAILURES "Max consecutive failures reached: {0}" "$ASC_CONSECUTIVE_FAILURES")"
         return 1
     fi
 
@@ -537,7 +562,7 @@ check_continue_conditions() {
     local runtime_hours=$(((current_time - ASC_START_TIME) / 3600))
 
     if [[ $runtime_hours -ge $ASC_MAX_RUNTIME_HOURS ]]; then
-        log_conductor "Max runtime reached: ${runtime_hours}h"
+        log_conductor "$(asc_msg MSG_ASC_MAX_RUNTIME "Max runtime reached: {0}h" "$runtime_hours")"
         return 1
     fi
 
@@ -547,14 +572,14 @@ check_continue_conditions() {
         current_hour=$(date +%H:%M)
 
         if [[ "$current_hour" > "$ASC_STOP_WINDOW" && "$current_hour" < "12:00" ]]; then
-            log_conductor "Stop window reached: $current_hour (window: $ASC_STOP_WINDOW)"
+            log_conductor "$(asc_msg MSG_ASC_STOP_WINDOW "Stop window reached: {0} (window: {1})" "$current_hour" "$ASC_STOP_WINDOW")"
             return 1
         fi
     fi
 
     # Check for critical escalations
     if type has_critical_pending &>/dev/null && has_critical_pending; then
-        log_conductor "Critical escalation pending - pausing"
+        log_conductor "$(asc_msg MSG_ASC_CRITICAL_ESCALATION "Critical escalation pending - pausing")"
 
         # Wait for resolution or timeout
         sleep 300  # 5 minutes
@@ -581,7 +606,7 @@ get_next_ready_story() {
     fi
 }
 
-# Get all ready-for-dev stories (for parallel processing)
+# Get all ready-for-dev stories (for parallel processing), one id per line
 get_all_ready_stories() {
     local bmad_dir="${BMAD_DIR:-.bmad}"
     local status_file="$bmad_dir/sprint-status.yaml"
@@ -595,16 +620,12 @@ get_all_ready_stories() {
             select(.value.status == "ready-for-dev") |
             select(.value.claimed_by == null or .value.claimed_by == "") |
             select(
-                (.value.blocked_by // []) | length == 0 or
-                (
-                    (.value.blocked_by // []) | all(
-                        . as $dep |
-                        ($stories[$dep].status == "done" or $stories[$dep].status == "review")
-                    )
-                )
+                [(.value.blocked_by // [])[] |
+                    select($stories[.].status != "done" and $stories[.].status != "review")
+                ] | length == 0
             ) |
             .key
-        ' "$status_file" 2>/dev/null | tr '\n' ' '
+        ' "$status_file" 2>/dev/null
     fi
 }
 
@@ -621,7 +642,7 @@ get_independent_ready_stories() {
             select(.value.claimed_by == null or .value.claimed_by == "") |
             select((.value.blocked_by // []) | length == 0) |
             .key
-        ' "$status_file" 2>/dev/null | tr '\n' ' '
+        ' "$status_file" 2>/dev/null
     fi
 }
 
@@ -634,11 +655,13 @@ claim_story() {
         local timestamp
         timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
-        yq -i ".stories.${story_id}.claimed_by = \"$ASC_SESSION_ID\"" "$status_file"
-        yq -i ".stories.${story_id}.claimed_at = \"$timestamp\"" "$status_file"
-        yq -i ".stories.${story_id}.status = \"in-progress\"" "$status_file"
+        # Ids and values go through strenv(): never parsed as yq expressions
+        STORY_ID="$story_id" OWNER="$ASC_SESSION_ID" TS="$timestamp" yq -i '
+            .stories[strenv(STORY_ID)].claimed_by = strenv(OWNER) |
+            .stories[strenv(STORY_ID)].claimed_at = strenv(TS) |
+            .stories[strenv(STORY_ID)].status = "in-progress"' "$status_file"
 
-        log_conductor "Claimed story: $story_id"
+        log_conductor "$(asc_msg MSG_ASC_CLAIMED "Claimed story: {0}" "$story_id")"
         return 0
     fi
 
@@ -651,10 +674,9 @@ unclaim_story() {
     local status_file="$bmad_dir/sprint-status.yaml"
 
     if [[ -f "$status_file" ]] && command -v yq &>/dev/null; then
-        yq -i ".stories.${story_id}.claimed_by = \"\"" "$status_file"
-        yq -i ".stories.${story_id}.claimed_at = \"\"" "$status_file"
+        STORY_ID="$story_id" yq -i '.stories[strenv(STORY_ID)].claimed_by = "" | .stories[strenv(STORY_ID)].claimed_at = ""' "$status_file"
 
-        log_conductor "Unclaimed story: $story_id"
+        log_conductor "$(asc_msg MSG_ASC_UNCLAIMED "Unclaimed story: {0}" "$story_id")"
         return 0
     fi
 
@@ -678,11 +700,12 @@ transition_story() {
         local timestamp
         timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
-        yq -i ".stories.${story_id}.previous_status = .stories.${story_id}.status" "$status_file"
-        yq -i ".stories.${story_id}.status = \"$new_status\"" "$status_file"
-        yq -i ".stories.${story_id}.updated_at = \"$timestamp\"" "$status_file"
+        STORY_ID="$story_id" NEW_STATUS="$new_status" TS="$timestamp" yq -i '
+            .stories[strenv(STORY_ID)].previous_status = .stories[strenv(STORY_ID)].status |
+            .stories[strenv(STORY_ID)].status = strenv(NEW_STATUS) |
+            .stories[strenv(STORY_ID)].updated_at = strenv(TS)' "$status_file"
 
-        log_conductor "Transitioned $story_id to $new_status"
+        log_conductor "$(asc_msg MSG_ASC_TRANSITIONED "Transitioned {0} to {1}" "$story_id" "$new_status")"
         return 0
     fi
 
@@ -696,16 +719,17 @@ transition_story() {
 execute_story_with_ralph() {
     local story_id="$1"
 
-    log_conductor "Spawning Ralph for story: $story_id"
+    log_conductor "$(asc_msg MSG_ASC_SPAWNING_RALPH "Spawning Ralph for story: {0}" "$story_id")"
 
     # Build prompt for Ralph
     local prompt
     prompt=$(build_story_prompt "$story_id")
 
-    # Get story-specific config if available
-    local story_config=""
-    if [[ -f ".ralph/stories/${story_id}.yml" ]]; then
-        story_config="--config=.ralph/stories/${story_id}.yml"
+    # Get story-specific config if available. An id with `/` (e.g. `../x`)
+    # would read a config outside .ralph/stories/: ignored.
+    local -a story_config=()
+    if [[ "$story_id" != */* && -f ".ralph/stories/${story_id}.yml" ]]; then
+        story_config=("--config=.ralph/stories/${story_id}.yml")
     fi
 
     # Run Ralph with autonomous profile
@@ -715,7 +739,7 @@ execute_story_with_ralph() {
         local output
         output=$("$ralph_script" \
             --lang="${LANG_ARG:-en}" \
-            $story_config \
+            "${story_config[@]}" \
             "$prompt" 2>&1)
         local status=$?
 
@@ -733,7 +757,7 @@ execute_story_with_ralph() {
                 ;;
         esac
     else
-        log_conductor "Ralph script not found: $ralph_script"
+        log_conductor "$(asc_msg MSG_ASC_RALPH_NOT_FOUND "Ralph script not found: {0}" "$ralph_script")"
         return 1
     fi
 }
@@ -747,9 +771,9 @@ build_story_prompt() {
 
     if [[ -f "$status_file" ]] && command -v yq &>/dev/null; then
         local title description acceptance_criteria
-        title=$(yq ".stories.${story_id}.title" "$status_file" 2>/dev/null)
-        description=$(yq ".stories.${story_id}.description" "$status_file" 2>/dev/null)
-        acceptance_criteria=$(yq ".stories.${story_id}.acceptance_criteria[]" "$status_file" 2>/dev/null | tr '\n' '; ')
+        title=$(STORY_ID="$story_id" yq '.stories[strenv(STORY_ID)].title' "$status_file" 2>/dev/null)
+        description=$(STORY_ID="$story_id" yq '.stories[strenv(STORY_ID)].description' "$status_file" 2>/dev/null)
+        acceptance_criteria=$(STORY_ID="$story_id" yq '.stories[strenv(STORY_ID)].acceptance_criteria[]' "$status_file" 2>/dev/null | tr '\n' '; ') || true
 
         prompt="Implement user story: $title
 
@@ -774,10 +798,10 @@ confirm_story_start() {
 
     echo ""
     echo "════════════════════════════════════════"
-    echo "    Supervised Mode: Story Ready"
+    echo "    $(asc_msg MSG_ASC_SUPERVISED_TITLE "Supervised Mode: Story Ready")"
     echo "════════════════════════════════════════"
     echo ""
-    echo "Story: $story_id"
+    echo "$(asc_msg MSG_ASC_SUPERVISED_STORY "Story: {0}" "$story_id")"
 
     if command -v yq &>/dev/null; then
         local bmad_dir="${BMAD_DIR:-.bmad}"
@@ -785,13 +809,13 @@ confirm_story_start() {
 
         if [[ -f "$status_file" ]]; then
             local title
-            title=$(yq ".stories.${story_id}.title" "$status_file" 2>/dev/null)
-            echo "Title: $title"
+            title=$(STORY_ID="$story_id" yq '.stories[strenv(STORY_ID)].title' "$status_file" 2>/dev/null)
+            echo "$(asc_msg MSG_ASC_SUPERVISED_TITLE_LINE "Title: {0}" "$title")"
         fi
     fi
 
     echo ""
-    read -rp "Start this story? (y/n/s for skip all): " response
+    read -rp "$(asc_msg MSG_ASC_SUPERVISED_PROMPT "Start this story? (y/n/s for skip all): ")" response
 
     case "$response" in
         y|Y) return 0 ;;
@@ -814,7 +838,7 @@ update_conductor_state() {
 
     case "$field" in
         current)
-            yq -i ".stories.current = \"$value\"" "$ASC_STATE_FILE"
+            VALUE="$value" yq -i '.stories.current = strenv(VALUE)' "$ASC_STATE_FILE"
             ;;
         stories)
             yq -i ".stories.completed = $ASC_STORIES_COMPLETED" "$ASC_STATE_FILE"
@@ -822,7 +846,7 @@ update_conductor_state() {
             yq -i ".stories.skipped = $ASC_STORIES_SKIPPED" "$ASC_STATE_FILE"
             ;;
         status)
-            yq -i ".status = \"$value\"" "$ASC_STATE_FILE"
+            VALUE="$value" yq -i '.status = strenv(VALUE)' "$ASC_STATE_FILE"
             ;;
     esac
 }
@@ -835,9 +859,9 @@ create_conductor_checkpoint() {
     local timestamp
     timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
-    yq -i ".checkpoints += [{
-        \"timestamp\": \"$timestamp\",
-        \"story\": \"$ASC_CURRENT_STORY\",
+    TS="$timestamp" STORY="$ASC_CURRENT_STORY" yq -i ".checkpoints += [{
+        \"timestamp\": strenv(TS),
+        \"story\": strenv(STORY),
         \"completed\": $ASC_STORIES_COMPLETED,
         \"failed\": $ASC_STORIES_FAILED,
         \"skipped\": $ASC_STORIES_SKIPPED
@@ -848,6 +872,19 @@ create_conductor_checkpoint() {
 # Logging
 # =============================================================================
 
+# Leader message in the --lang language: asc_msg <MSG_ var> <English default>
+# [values for {0} {1}...] (MSG_ASC_* strings live in Tools/i18n/ralph/<lang>.sh)
+asc_msg() {
+    local msg="${!1:-$2}"
+    shift 2
+    local i=0 value
+    for value in "$@"; do
+        msg="${msg//\{$i\}/"$value"}"
+        i=$((i + 1))
+    done
+    printf '%s' "$msg"
+}
+
 log_conductor() {
     local message="$1"
     local timestamp
@@ -866,7 +903,7 @@ print_header_conductor() {
 
     echo ""
     echo -e "${C_CYAN}╔════════════════════════════════════════════════════════════╗${C_RESET}"
-    echo -e "${C_CYAN}║${C_RESET}     ${C_BOLD}Autonomous Sprint Conductor (ASC)${C_RESET}              ${C_CYAN}║${C_RESET}"
+    echo -e "${C_CYAN}║${C_RESET}     ${C_BOLD}$(asc_msg MSG_ASC_HEADER "Autonomous Sprint Conductor (ASC)")${C_RESET}              ${C_CYAN}║${C_RESET}"
     echo -e "${C_CYAN}║${C_RESET}     ${C_DIM}$sprint_name${C_RESET}                                    ${C_CYAN}║${C_RESET}"
     echo -e "${C_CYAN}╚════════════════════════════════════════════════════════════╝${C_RESET}"
     echo ""
@@ -897,33 +934,33 @@ finalize_sprint_conductor() {
     # Print summary
     echo ""
     echo "════════════════════════════════════════"
-    echo "    Sprint Conductor Summary"
+    echo "    $(asc_msg MSG_ASC_SUMMARY "Sprint Conductor Summary")"
     echo "════════════════════════════════════════"
     echo ""
-    echo "Session: $ASC_SESSION_ID"
-    echo "Duration: ${duration_hours}h ${duration_mins}m"
+    echo "$(asc_msg MSG_ASC_SUMMARY_SESSION "Session: {0}" "$ASC_SESSION_ID")"
+    echo "$(asc_msg MSG_ASC_SUMMARY_DURATION "Duration: {0}h {1}m" "$duration_hours" "$duration_mins")"
     echo ""
-    echo "Stories:"
-    echo "  Completed: $ASC_STORIES_COMPLETED"
-    echo "  Failed:    $ASC_STORIES_FAILED"
-    echo "  Skipped:   $ASC_STORIES_SKIPPED"
+    echo "$(asc_msg MSG_ASC_SUMMARY_STORIES "Stories:")"
+    echo "$(asc_msg MSG_ASC_SUMMARY_COMPLETED "  Completed: {0}" "$ASC_STORIES_COMPLETED")"
+    echo "$(asc_msg MSG_ASC_SUMMARY_FAILED "  Failed:    {0}" "$ASC_STORIES_FAILED")"
+    echo "$(asc_msg MSG_ASC_SUMMARY_SKIPPED "  Skipped:   {0}" "$ASC_STORIES_SKIPPED")"
     echo ""
 
     # Show escalation stats if available
     if type get_escalation_stats &>/dev/null; then
-        echo "Escalations:"
+        echo "$(asc_msg MSG_ASC_SUMMARY_ESCALATIONS "Escalations:")"
         get_escalation_stats | jq -r 'to_entries[] | "  \(.key): \(.value)"' 2>/dev/null || echo "  N/A"
         echo ""
     fi
 
     # Show recovery stats if available
     if type get_recovery_stats &>/dev/null; then
-        echo "Recovery attempts:"
+        echo "$(asc_msg MSG_ASC_SUMMARY_RECOVERY "Recovery attempts:")"
         get_recovery_stats "$ASC_SESSION_ID" | jq -r '.total_attempts // 0' 2>/dev/null || echo "  N/A"
         echo ""
     fi
 
-    log_conductor "Sprint Conductor completed"
+    log_conductor "$(asc_msg MSG_ASC_DONE "Sprint Conductor completed")"
 }
 
 generate_conductor_metrics() {
@@ -969,11 +1006,17 @@ cmd_sprint_conductor() {
             --parallel) parallel="$2"; ASC_PARALLEL_ENABLED="true"; ASC_PARALLEL_MAX="$2"; shift 2 ;;
             --max-stories) max_stories="$2"; shift 2 ;;
             --timeout) timeout="$2"; shift 2 ;;
+            --lang=*) LANG_ARG="${1#--lang=}"; shift ;;
             -*) shift ;;
             *) sprint_name="$1"; shift ;;
         esac
     done
 
+    # Messages were loaded before --lang was read: reload them for the leader
+    if type load_messages &>/dev/null; then
+        load_messages
+    fi
+
     if [[ -z "$sprint_name" ]]; then
         echo "Usage: sprint-conductor.sh [options] <sprint-name>"
         echo ""