autonomous-coding-toolkit 1.0.0

package/scripts/lib/run-plan-routing.sh

@@ -0,0 +1,315 @@
+#!/usr/bin/env bash
+# run-plan-routing.sh — Plan analysis, dependency graph, and execution mode routing
+#
+# Analyzes plan structure to determine optimal execution mode.
+# Builds dependency graphs from Files/context_refs metadata.
+#
+# Functions:
+#   build_dependency_graph <plan_file>              -> JSON {batch: [deps]}
+#   compute_parallelism_score <plan_file>           -> 0-100 score
+#   recommend_execution_mode <score> <teams_avail> <mem_gb> -> headless|team
+#   classify_batch_model <plan_file> <batch_num>    -> sonnet|haiku|opus
+#   generate_routing_plan <plan_file> <score> <teams_avail> <mem_gb> <mode> -> printed plan
+#   log_routing_decision <worktree> <category> <message>
+
+# --- Configuration ---
+PARALLELISM_THRESHOLD_TEAM=40    # Score above this recommends team mode
+MIN_MEMORY_TEAM_GB=8             # Minimum memory for team mode
+# shellcheck disable=SC2034  # MIN_BATCHES_TEAM reserved for future use
+MIN_BATCHES_TEAM=3               # Need at least 3 batches to justify team mode
+
+# --- Sampling configuration ---
+# shellcheck disable=SC2034  # consumed by run-plan-headless.sh
+SAMPLE_ON_RETRY=true             # auto-sample when batch fails first attempt
+# shellcheck disable=SC2034
+SAMPLE_ON_CRITICAL=true          # auto-sample for CRITICAL batches
+# shellcheck disable=SC2034
+SAMPLE_DEFAULT_COUNT=3           # default candidate count
+# shellcheck disable=SC2034
+SAMPLE_MAX_COUNT=5               # hard cap
+# shellcheck disable=SC2034
+SAMPLE_MIN_MEMORY_PER_GB=4       # per-candidate memory requirement (GB)
+
+# --- Extract files touched by a batch ---
+# Returns lines like "Create:src/lib.sh" or "Modify:src/lib.sh"
+_get_batch_files() {
+    local plan_file="$1" batch_num="$2"
+    local batch_text
+    batch_text=$(get_batch_text "$plan_file" "$batch_num")
+    echo "$batch_text" | grep -oE '(Create|Modify): `[^`]+`' | sed 's/`//g; s/: /:/g' || true
+}
+
+# --- Build dependency graph ---
+# Returns JSON: {"1": [], "2": ["1"], "3": ["1"], "4": ["2","3"]}
+build_dependency_graph() {
+    local plan_file="$1"
+    local total
+    total=$(count_batches "$plan_file")
+
+    # Phase 1: collect files each batch creates/modifies
+    declare -A creates
+    declare -A modifies
+
+    for ((b = 1; b <= total; b++)); do
+        local files
+        files=$(_get_batch_files "$plan_file" "$b")
+        while IFS= read -r line; do
+            [[ -z "$line" ]] && continue
+            local action="${line%%:*}"
+            local file="${line#*:}"
+            if [[ "$action" == "Create" ]]; then
+                creates["$file"]="$b"
+            fi
+            # Track all batches that touch each file (Create or Modify)
+            modifies["$file"]="${modifies[$file]:-} $b"
+        done <<< "$files"
+    done
+
+    # Phase 2: find dependencies (Create→Modify, Modify→Modify, context_refs)
+    local graph="{"
+    for ((b = 1; b <= total; b++)); do
+        local deps=()
+
+        local files
+        files=$(_get_batch_files "$plan_file" "$b")
+        while IFS= read -r line; do
+            [[ -z "$line" ]] && continue
+            local action="${line%%:*}"
+            local file="${line#*:}"
+            if [[ "$action" == "Modify" ]]; then
+                local creator="${creates[$file]:-}"
+                if [[ -n "$creator" && "$creator" != "$b" ]]; then
+                    deps+=("$creator")
+                fi
+                local touchers="${modifies[$file]:-}"
+                for t in $touchers; do
+                    if [[ "$t" -lt "$b" ]]; then
+                        deps+=("$t")
+                    fi
+                done
+            fi
+        done <<< "$files"
+
+        # Check context_refs
+        local refs
+        refs=$(get_batch_context_refs "$plan_file" "$b" 2>/dev/null || true)
+        while IFS= read -r ref; do
+            ref=$(echo "$ref" | xargs)
+            [[ -z "$ref" ]] && continue
+            local creator="${creates[$ref]:-}"
+            if [[ -n "$creator" && "$creator" != "$b" ]]; then
+                deps+=("$creator")
+            fi
+        done <<< "$refs"
+
+        # Deduplicate deps
+        local unique_deps=()
+        local seen=""
+        for d in "${deps[@]+"${deps[@]}"}"; do
+            if [[ "$seen" != *"|$d|"* ]]; then
+                unique_deps+=("$d")
+                seen+="|$d|"
+            fi
+        done
+
+        # Build JSON array
+        local deps_json="[]"
+        if [[ ${#unique_deps[@]} -gt 0 ]]; then
+            deps_json="["
+            for ((i = 0; i < ${#unique_deps[@]}; i++)); do
+                [[ $i -gt 0 ]] && deps_json+=","
+                deps_json+="\"${unique_deps[$i]}\""
+            done
+            deps_json+="]"
+        fi
+
+        [[ "$b" -gt 1 ]] && graph+=","
+        graph+="\"$b\":$deps_json"
+    done
+    graph+="}"
+
+    echo "$graph"
+}
+
+# --- Compute parallelism score (0-100) ---
+# Higher = more batches can run in parallel
+compute_parallelism_score() {
+    local plan_file="$1"
+    local total
+    total=$(count_batches "$plan_file")
+
+    if [[ "$total" -le 1 ]]; then
+        echo "0"
+        return
+    fi
+
+    local graph
+    graph=$(build_dependency_graph "$plan_file")
+
+    # Topological sort into parallel groups
+    local completed=""
+    local groups=0
+    local max_group_size=0
+    local remaining="$total"
+
+    while [[ "$remaining" -gt 0 ]]; do
+        groups=$((groups + 1))
+        local group_size=0
+        local new_completed=""
+
+        for ((b = 1; b <= total; b++)); do
+            # Skip already completed
+            [[ "$completed" == *"|$b|"* ]] && continue
+
+            local deps
+            deps=$(echo "$graph" | timeout 30 jq -r ".\"$b\"[]" 2>/dev/null) || {
+                [[ $? -eq 124 ]] && echo "[WARN] jq timeout on batch $b — treating as no deps" >&2
+                deps=""
+            }
+            local all_met=true
+            while IFS= read -r dep; do
+                [[ -z "$dep" ]] && continue
+                if [[ "$completed" != *"|$dep|"* ]]; then
+                    all_met=false
+                    break
+                fi
+            done <<< "$deps"
+
+            if [[ "$all_met" == true ]]; then
+                new_completed+="|$b|"
+                group_size=$((group_size + 1))
+                remaining=$((remaining - 1))
+            fi
+        done
+
+        completed+="$new_completed"
+
+        if [[ "$group_size" -gt "$max_group_size" ]]; then
+            max_group_size=$group_size
+        fi
+
+        if [[ "$group_size" -eq 0 ]]; then
+            break
+        fi
+    done
+
+    # Score: weighted parallel_ratio (70%) + group_savings (30%)
+    local parallel_ratio=$(( (max_group_size * 100) / total ))
+    local denom=$(( total - 1 ))
+    [[ "$denom" -lt 1 ]] && denom=1
+    local group_savings=$(( (total - groups) * 100 / denom ))
+    local score=$(( (parallel_ratio * 7 + group_savings * 3) / 10 ))
+
+    # Clamp to 0-100
+    [[ "$score" -gt 100 ]] && score=100
+    [[ "$score" -lt 0 ]] && score=0
+
+    echo "$score"
+}
+
+# --- Recommend execution mode ---
+recommend_execution_mode() {
+    local score="$1"
+    local teams_available="${2:-false}"
+    local available_mem_gb="${3:-0}"
+
+    if [[ "$score" -ge "$PARALLELISM_THRESHOLD_TEAM" && "$available_mem_gb" -ge "$MIN_MEMORY_TEAM_GB" ]]; then
+        echo "team"
+    else
+        echo "headless"
+    fi
+}
+
+# --- Classify batch model (sonnet/haiku/opus) ---
+classify_batch_model() {
+    local plan_file="$1" batch_num="$2"
+    local batch_text
+    batch_text=$(get_batch_text "$plan_file" "$batch_num")
+
+    # Check for Create files — needs implementation skill = sonnet
+    if echo "$batch_text" | grep -qE -- '^\*\*Files:\*\*' && echo "$batch_text" | grep -qE -- 'Create:'; then
+        echo "sonnet"
+        return
+    fi
+
+    # Check for Modify files — needs understanding + editing = sonnet
+    if echo "$batch_text" | grep -qE -- 'Modify:'; then
+        echo "sonnet"
+        return
+    fi
+
+    # Check if batch is mostly Run commands (verification) = haiku
+    local total_steps
+    total_steps=$(echo "$batch_text" | grep -cE -- '^\*\*Step [0-9]+' 2>/dev/null || true)
+    total_steps=${total_steps:-0}
+    local run_steps
+    run_steps=$(echo "$batch_text" | grep -cE -- '^Run: ' 2>/dev/null || true)
+    run_steps=${run_steps:-0}
+    if [[ "$total_steps" -gt 0 && "$run_steps" -ge "$total_steps" ]]; then
+        echo "haiku"
+        return
+    fi
+
+    # Check for CRITICAL tag = opus
+    local title
+    title=$(get_batch_title "$plan_file" "$batch_num")
+    if [[ "$title" == *"CRITICAL"* ]]; then
+        echo "opus"
+        return
+    fi
+
+    # Default: sonnet
+    echo "sonnet"
+}
+
+# --- Generate human-readable routing plan ---
+generate_routing_plan() {
+    local plan_file="$1" score="$2" teams_available="$3" mem_gb="$4" current_mode="$5"
+    local total
+    total=$(count_batches "$plan_file")
+
+    echo ""
+    echo "=== Routing Analysis ==="
+    echo "  Batches: $total"
+    echo "  Parallelism score: $score/100"
+    echo "  Teams available: $teams_available"
+    echo "  Memory: ${mem_gb}GB"
+    echo ""
+
+    # Show dependency graph
+    local graph
+    graph=$(build_dependency_graph "$plan_file")
+    echo "  Dependency graph:"
+    for ((b = 1; b <= total; b++)); do
+        local deps
+        deps=$(echo "$graph" | timeout 30 jq -r ".\"$b\" | join(\",\")" 2>/dev/null) || {
+            [[ $? -eq 124 ]] && echo "[WARN] jq timeout on batch $b — treating as no deps" >&2
+            deps=""
+        }
+        local title
+        title=$(get_batch_title "$plan_file" "$b")
+        local model
+        model=$(classify_batch_model "$plan_file" "$b")
+        if [[ -z "$deps" ]]; then
+            echo "    Batch $b: $title [$model] (no deps)"
+        else
+            echo "    Batch $b: $title [$model] (depends on: $deps)"
+        fi
+    done
+
+    echo ""
+    local recommended
+    recommended=$(recommend_execution_mode "$score" "$teams_available" "$mem_gb")
+    echo "  Recommended mode: $recommended"
+    if [[ "$current_mode" != "auto" && "$current_mode" != "$recommended" ]]; then
+        echo "  (overridden by --mode $current_mode)"
+    fi
+}
+
+# --- Routing decision logger ---
+log_routing_decision() {
+    local worktree="$1" category="$2" message="$3"
+    local log_file="$worktree/logs/routing-decisions.log"
+    mkdir -p "$(dirname "$log_file")"
+    echo "[$(date '+%H:%M:%S')] $category: $message" >> "$log_file"
+}

package/scripts/lib/run-plan-sampling.sh

@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+# run-plan-sampling.sh — Parallel candidate sampling for batch execution
+#
+# Standalone module: spawns N parallel candidates with prompt variants,
+# scores each via quality gate, picks the winner. Uses patch files (not stash)
+# to manage worktree state across candidates.
+#
+# Functions:
+#   check_memory_for_sampling
+#     Returns 0 if enough memory for SAMPLE_COUNT candidates, 1 otherwise.
+#   run_sampling_candidates <worktree> <plan_file> <batch> <prompt> <quality_gate_cmd>
+#     Spawns SAMPLE_COUNT candidates, scores them, applies winner's patch.
+#     Returns 0 if winner found, 1 if no candidate passed.
+#
+# Globals (read-only): SAMPLE_COUNT, SAMPLE_MIN_MEMORY_PER_GB
+# Requires libs: run-plan-scoring (score_candidate, select_winner, classify_batch_type, get_prompt_variants)
+#                run-plan-quality-gate (run_quality_gate)
+#                run-plan-state (get_previous_test_count)
+
+check_memory_for_sampling() {
+    local avail_mb
+    avail_mb=$(free -m 2>/dev/null | awk '/Mem:/{print $7}')
+    if [[ -z "$avail_mb" ]]; then
+        echo "  WARNING: Cannot determine available memory. Falling back to single attempt."
+        SAMPLE_COUNT=0
+        return 1
+    fi
+
+    local needed_mb=$(( SAMPLE_COUNT * ${SAMPLE_MIN_MEMORY_PER_GB:-4} * 1024 ))
+    if [[ "$avail_mb" -lt "$needed_mb" ]]; then
+        local avail_display needed_display
+        avail_display=$(awk "BEGIN {printf \"%.1f\", $avail_mb / 1024}")
+        needed_display=$(( SAMPLE_COUNT * ${SAMPLE_MIN_MEMORY_PER_GB:-4} ))
+        echo "  WARNING: Not enough memory for sampling (${avail_display}G < ${needed_display}G needed). Falling back to single attempt."
+        SAMPLE_COUNT=0
+        return 1
+    fi
+    return 0
+}
+
+run_sampling_candidates() {
+    local worktree="$1"
+    local plan_file="$2"
+    local batch="$3"
+    local prompt="$4"
+    local quality_gate_cmd="$5"
+
+    echo "  Sampling $SAMPLE_COUNT candidates for batch $batch..."
+    local scores=""
+    local candidate_logs=()
+
+    # Save baseline state using a patch file rather than git stash.
+    # This avoids LIFO ordering issues when multiple stash/pop cycles
+    # interact: stash.pop always restores the top entry, so interleaved
+    # stash calls across candidates can restore the wrong state (#2).
+    # Using patch files gives explicit, named state snapshots instead.
+    local _baseline_patch="/tmp/run-plan-baseline-${batch}-$$.diff"
+    (cd "$worktree" && git diff > "$_baseline_patch" 2>/dev/null || true)
+
+    # Classify batch and get type-aware prompt variants
+    local batch_type
+    batch_type=$(classify_batch_type "$plan_file" "$batch")
+    local variants
+    variants=$(get_prompt_variants "$batch_type" "$worktree/logs/sampling-outcomes.json" "$SAMPLE_COUNT")
+
+    local c=0
+    local _winner_patch=""
+    while IFS= read -r variant_name; do
+        local variant_suffix=""
+        if [[ "$variant_name" != "vanilla" ]]; then
+            variant_suffix=$'\nIMPORTANT: '"$variant_name"
+        fi
+
+        local candidate_log="$worktree/logs/batch-${batch}-candidate-${c}.log"
+        candidate_logs+=("$candidate_log")
+
+        # Restore clean baseline for each candidate using the saved patch.
+        # Reset tracked changes first, then re-apply the baseline diff.
+        (cd "$worktree" && git checkout . 2>/dev/null || true)
+        if [[ -s "$_baseline_patch" ]]; then
+            if ! (cd "$worktree" && git apply "$_baseline_patch" 2>/dev/null); then
+                echo "  WARNING: Failed to restore baseline patch for candidate $c — starting from clean state" >&2
+            fi
+        fi
+
+        CLAUDECODE='' claude -p "${prompt}${variant_suffix}" \
+            --allowedTools "Bash,Read,Write,Edit,Grep,Glob" \
+            --permission-mode bypassPermissions \
+            > "$candidate_log" 2>&1 || true
+
+        # Score this candidate
+        local gate_exit=0
+        run_quality_gate "$worktree" "$quality_gate_cmd" "sample-$c" "0" || gate_exit=$?
+        local gate_passed=0
+        [[ $gate_exit -eq 0 ]] && gate_passed=1
+
+        local new_tests
+        new_tests=$(get_previous_test_count "$worktree")
+        local diff_size
+        diff_size=$(cd "$worktree" && git diff --stat HEAD 2>/dev/null | tail -1 | grep -oE '[0-9]+' | head -1 || echo "100")
+
+        local score
+        score=$(score_candidate "$gate_passed" "${new_tests:-0}" "${diff_size:-100}" "0" "0" "0")
+        scores+="$score "
+
+        echo "  Candidate $c: score=$score (gate=$gate_passed, tests=${new_tests:-0})"
+
+        # Save winning candidate's state as a patch file for later restore.
+        # Only the last passing candidate's patch is kept as the winner
+        # (select_winner picks the highest score, which is last-wins on tie).
+        if [[ $gate_passed -eq 1 ]]; then
+            _winner_patch="/tmp/run-plan-winner-${batch}-${c}-$$.diff"
+            (cd "$worktree" && git diff > "$_winner_patch" 2>/dev/null || true)
+        fi
+
+        # Reset worktree for next candidate iteration
+        (cd "$worktree" && git checkout . 2>/dev/null || true)
+
+        c=$((c + 1))
+    done <<< "$variants"
+
+    # Pick winner
+    local winner
+    winner=$(select_winner "$scores")
+    if [[ "$winner" -ge 0 ]]; then
+        echo "  Winner: candidate $winner (scores: $scores)"
+
+        # Restore winner's patch — explicit named file, no LIFO ordering risk
+        local _apply_patch="/tmp/run-plan-winner-${batch}-${winner}-$$.diff"
+        if [[ -s "$_apply_patch" ]]; then
+            if ! (cd "$worktree" && git apply "$_apply_patch"); then
+                echo "  ERROR: Failed to apply winning candidate $winner patch — sampling result lost" >&2
+                # Clean up temp patch files
+                rm -f "$_baseline_patch" /tmp/run-plan-winner-${batch}-*-$$.diff 2>/dev/null || true
+                return 1
+            fi
+        fi
+
+        # Log sampling outcome
+        local outcomes_file="$worktree/logs/sampling-outcomes.json"
+        mkdir -p "$(dirname "$outcomes_file")"
+        [[ ! -f "$outcomes_file" ]] && echo "[]" > "$outcomes_file"
+
+        # Get the winning variant name from the variants list
+        local winning_variant
+        winning_variant=$(echo "$variants" | sed -n "$((winner + 1))p")
+        winning_variant="${winning_variant:-vanilla}"
+
+        jq --arg bt "$batch_type" --arg vn "$winning_variant" --arg sc "$(echo "$scores" | awk '{print $1}')" \
+            '. += [{"batch_type": $bt, "prompt_variant": $vn, "won": true, "score": ($sc | tonumber), "timestamp": now | tostring}]' \
+            "$outcomes_file" > "$outcomes_file.tmp" && mv "$outcomes_file.tmp" "$outcomes_file" || true
+
+        # Clean up temp patch files
+        rm -f "$_baseline_patch" /tmp/run-plan-winner-${batch}-*-$$.diff 2>/dev/null || true
+        return 0
+    else
+        echo "  No candidate passed quality gate"
+        # Restore baseline state for the normal retry path
+        if [[ -s "$_baseline_patch" ]]; then
+            if ! (cd "$worktree" && git apply "$_baseline_patch" 2>/dev/null); then
+                echo "  WARNING: Failed to restore baseline after sampling — continuing from clean state" >&2
+            fi
+        fi
+    fi
+
+    # Clean up temp patch files
+    rm -f "$_baseline_patch" /tmp/run-plan-winner-${batch}-*-$$.diff 2>/dev/null || true
+
+    return 1
+}

package/scripts/lib/run-plan-scoring.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+# run-plan-scoring.sh — Candidate scoring for parallel patch sampling
+#
+# Functions:
+#   score_candidate <gate_passed> <test_count> <diff_lines> <lint_warnings> <lesson_violations> <ast_violations>
+#   select_winner <scores_string>  -> index of highest score (0-based), -1 if all zero
+
+score_candidate() {
+    local gate_passed="${1:-0}"
+    local test_count="${2:-0}"
+    local diff_lines="${3:-1}"
+    local lint_warnings="${4:-0}"
+    local lesson_violations="${5:-0}"
+    local ast_violations="${6:-0}"
+
+    if [[ "$gate_passed" -ne 1 ]]; then
+        echo 0
+        return
+    fi
+
+    # Avoid division by zero
+    [[ "$diff_lines" -lt 1 ]] && diff_lines=1
+
+    local score=$(( (test_count * 10) + (10000 / (diff_lines + 1)) + (1000 / (lint_warnings + 1)) - (lesson_violations * 200) - (ast_violations * 100) ))
+
+    # Floor at 1 (gate passed = always positive)
+    [[ "$score" -lt 1 ]] && score=1
+    echo "$score"
+}
+
+select_winner() {
+    local scores_str="$1"
+    local max_score=0
+    local max_idx=-1
+    local idx=0
+
+    for score in $scores_str; do
+        if [[ "$score" -gt "$max_score" ]]; then
+            max_score="$score"
+            max_idx=$idx
+        fi
+        idx=$((idx + 1))
+    done
+
+    echo "$max_idx"
+}
+
+# Classify a batch by its dominant action type.
+# Returns: new-file | refactoring | integration | test-only | unknown
+classify_batch_type() {
+    local plan_file="$1" batch_num="$2"
+    local batch_text title
+
+    # Source parser if not already loaded
+    type get_batch_text &>/dev/null || source "$(dirname "${BASH_SOURCE[0]}")/run-plan-parser.sh"
+
+    batch_text=$(get_batch_text "$plan_file" "$batch_num" 2>/dev/null || true)
+    title=$(get_batch_title "$plan_file" "$batch_num" 2>/dev/null || true)
+
+    # Check title for integration keywords
+    if echo "$title" | grep -qiE 'integrat|wir|connect|glue'; then
+        echo "integration"
+        return
+    fi
+
+    local creates modifies runs
+    creates=$(echo "$batch_text" | grep -cE '^\s*-\s*Create:' || true)
+    creates=${creates:-0}
+    modifies=$(echo "$batch_text" | grep -cE '^\s*-\s*Modify:' || true)
+    modifies=${modifies:-0}
+    runs=$(echo "$batch_text" | grep -cE '^Run:' || true)
+    runs=${runs:-0}
+
+    # Test-only: only Run commands, no Create/Modify
+    if [[ "$creates" -eq 0 && "$modifies" -eq 0 && "$runs" -gt 0 ]]; then
+        echo "test-only"
+        return
+    fi
+
+    # New file creation dominant
+    if [[ "$creates" -gt "$modifies" ]]; then
+        echo "new-file"
+        return
+    fi
+
+    # Refactoring: modifications dominant
+    if [[ "$modifies" -gt 0 ]]; then
+        echo "refactoring"
+        return
+    fi
+
+    echo "unknown"
+}
+
+# Get prompt variant suffixes for a batch type.
+# Uses learned outcomes if available, otherwise defaults.
+# Args: <batch_type> <outcomes_file> <count>
+# Output: N lines, each a prompt suffix string
+get_prompt_variants() {
+    local batch_type="$1"
+    local outcomes_file="$2"
+    local count="${3:-3}"
+
+    # Default variants per batch type
+    local -A type_variants
+    type_variants[new-file]="check all imports before running tests|write tests first then implement"
+    type_variants[refactoring]="minimal change only|run tests after each edit"
+    type_variants[integration]="trace end-to-end before declaring done|check every import and export"
+    type_variants[test-only]="use real objects not mocks|focus on edge cases only"
+    type_variants[unknown]="try a different approach|make the minimum possible change"
+
+    local defaults="${type_variants[$batch_type]:-${type_variants[unknown]}}"
+
+    # Slot 1: always vanilla
+    echo "vanilla"
+
+    # Check for learned winners
+    local learned_variant=""
+    if [[ -f "$outcomes_file" ]]; then
+        learned_variant=$(jq -r --arg bt "$batch_type" \
+            '[.[] | select(.batch_type == $bt and .won == true)] | sort_by(.score) | reverse | .[0].prompt_variant // empty' \
+            "$outcomes_file" 2>/dev/null || true)
+    fi
+
+    # Slot 2: learned winner or first default
+    local variant2="${learned_variant:-$(echo "$defaults" | cut -d'|' -f1)}"
+    if [[ "$count" -ge 2 ]]; then
+        echo "$variant2"
+    fi
+
+    # Slot 3+: remaining defaults (exploration)
+    local slot=3
+    IFS='|' read -ra parts <<< "$defaults"
+    for part in "${parts[@]}"; do
+        [[ "$slot" -gt "$count" ]] && break
+        [[ "$part" == "$variant2" ]] && continue
+        echo "$part"
+        slot=$((slot + 1))
+    done
+
+    # Fill remaining slots with generic variants
+    while [[ "$slot" -le "$count" ]]; do
+        echo "try a fundamentally different approach"
+        slot=$((slot + 1))
+    done
+}