loki-mode 6.17.2 → 6.19.0

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.17.2
+# Loki Mode v6.19.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -267,4 +267,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.17.2 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.19.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.17.2
+6.19.0

package/autonomy/loki

@@ -435,6 +435,8 @@ show_help() {
     echo "  agent [cmd]      Agent type dispatch (list|info|run|start|review)"
     echo "  remote [PRD]     Start remote session (connect from phone/browser, Claude Pro/Max)"
   echo "  trigger          Event-driven autonomous execution (schedules, webhooks)"
+    echo "  failover [cmd]   Cross-provider auto-failover (status|--enable|--test|--chain)"
+    echo "  plan <PRD>       Dry-run PRD analysis: complexity, cost, and execution plan"
     echo "  version          Show version"
     echo "  help             Show this help"
     echo ""
@@ -8298,6 +8300,726 @@ for line in sys.stdin:
     esac
 }
 
+# Cross-provider auto-failover management (v6.19.0)
+cmd_failover() {
+    local loki_dir="${TARGET_DIR:-.}/.loki"
+    local failover_file="$loki_dir/state/failover.json"
+    local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+    if [ $# -eq 0 ]; then
+        # No args: show current failover config and health
+        if [ ! -f "$failover_file" ]; then
+            echo -e "${BOLD}Cross-Provider Auto-Failover${NC}"
+            echo ""
+            echo "Status: DISABLED"
+            echo ""
+            echo "Enable with: loki failover --enable"
+            echo "Or set:      LOKI_FAILOVER=true loki start"
+            return 0
+        fi
+
+        echo -e "${BOLD}Cross-Provider Auto-Failover${NC}"
+        echo ""
+        python3 << 'PYEOF'
+import json, os
+fpath = os.path.join(os.environ.get('TARGET_DIR', '.'), '.loki/state/failover.json')
+try:
+    with open(fpath) as f:
+        d = json.load(f)
+    status = "ENABLED" if d.get("enabled") else "DISABLED"
+    print(f"Status:           {status}")
+    print(f"Chain:            {' -> '.join(d.get('chain', []))}")
+    print(f"Current provider: {d.get('currentProvider', 'unknown')}")
+    print(f"Primary provider: {d.get('primaryProvider', 'unknown')}")
+    print(f"Failover count:   {d.get('failoverCount', 0)}")
+    last = d.get('lastFailover')
+    print(f"Last failover:    {last if last else 'never'}")
+    print()
+    print("Health Status:")
+    health = d.get('healthCheck', {})
+    for provider in d.get('chain', []):
+        h = health.get(provider, 'unknown')
+        indicator = '[OK]' if h == 'healthy' else '[--]' if h == 'unknown' else '[!!]'
+        print(f"  {indicator} {provider}: {h}")
+except FileNotFoundError:
+    print("Failover not initialized. Run: loki failover --enable")
+except Exception as e:
+    print(f"Error reading failover state: {e}")
+PYEOF
+        return 0
+    fi
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --enable)
+                mkdir -p "$loki_dir/state"
+                local current_provider
+                current_provider=$(cat "$loki_dir/state/provider" 2>/dev/null || echo "claude")
+                local chain="${LOKI_FAILOVER_CHAIN:-claude,codex,gemini}"
+
+                cat > "$failover_file" << FEOF
+{
+  "enabled": true,
+  "chain": $(printf '%s' "$chain" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read().strip().split(",")))' 2>/dev/null || echo '["claude","codex","gemini"]'),
+  "currentProvider": "$current_provider",
+  "primaryProvider": "$current_provider",
+  "lastFailover": null,
+  "failoverCount": 0,
+  "healthCheck": {}
+}
+FEOF
+                echo -e "${GREEN}Failover enabled${NC}"
+                echo "Chain: $chain"
+                echo "Primary: $current_provider"
+                shift
+                ;;
+            --disable)
+                if [ -f "$failover_file" ]; then
+                    python3 -c "
+import json
+with open('$failover_file') as f: d = json.load(f)
+d['enabled'] = False
+with open('$failover_file', 'w') as f: json.dump(d, f, indent=2)
+" 2>/dev/null
+                    echo -e "${YELLOW}Failover disabled${NC}"
+                else
+                    echo "Failover not initialized."
+                fi
+                shift
+                ;;
+            --chain)
+                shift
+                local new_chain="$1"
+                if [ -z "$new_chain" ]; then
+                    echo -e "${RED}Error: --chain requires a comma-separated list of providers${NC}"
+                    return 1
+                fi
+                # Validate each provider in chain
+                local IFS=','
+                for p in $new_chain; do
+                    case "$p" in
+                        claude|codex|gemini|cline|aider) ;;
+                        *) echo -e "${RED}Error: invalid provider '$p' in chain${NC}"; return 1 ;;
+                    esac
+                done
+                unset IFS
+
+                if [ ! -f "$failover_file" ]; then
+                    echo -e "${RED}Error: failover not initialized. Run: loki failover --enable${NC}"
+                    return 1
+                fi
+
+                python3 -c "
+import json
+with open('$failover_file') as f: d = json.load(f)
+d['chain'] = '$new_chain'.split(',')
+with open('$failover_file', 'w') as f: json.dump(d, f, indent=2)
+" 2>/dev/null
+                echo "Failover chain updated: $new_chain"
+                shift
+                ;;
+            --test)
+                echo -e "${BOLD}Testing all providers in failover chain...${NC}"
+                echo ""
+                # Source provider loader for health checks
+                if [ -f "$script_dir/../providers/loader.sh" ]; then
+                    source "$script_dir/../providers/loader.sh"
+                fi
+
+                local chain_providers="claude,codex,gemini"
+                if [ -f "$failover_file" ]; then
+                    chain_providers=$(python3 -c "import json; print(','.join(json.load(open('$failover_file')).get('chain', ['claude','codex','gemini'])))" 2>/dev/null || echo "claude,codex,gemini")
+                fi
+
+                local IFS=','
+                local all_pass=true
+                for p in $chain_providers; do
+                    printf "  %-10s " "$p:"
+
+                    # Check CLI installed
+                    local cli_name="$p"
+                    if command -v "$cli_name" &>/dev/null; then
+                        local cli_version
+                        cli_version=$("$cli_name" --version 2>/dev/null | head -1 || echo "unknown")
+                        printf "CLI %-20s " "[$cli_version]"
+                    else
+                        printf "CLI %-20s " "[NOT INSTALLED]"
+                        echo -e "${RED}FAIL${NC}"
+                        all_pass=false
+                        continue
+                    fi
+
+                    # Check API key
+                    local has_key=false
+                    case "$p" in
+                        claude) [ -n "${ANTHROPIC_API_KEY:-}" ] && has_key=true ;;
+                        codex) [ -n "${OPENAI_API_KEY:-}" ] && has_key=true ;;
+                        gemini) [ -n "${GOOGLE_API_KEY:-${GEMINI_API_KEY:-}}" ] && has_key=true ;;
+                        cline|aider) has_key=true ;;  # Key check varies
+                    esac
+
+                    if [ "$has_key" = "true" ]; then
+                        printf "Key [OK]  "
+                        echo -e "${GREEN}PASS${NC}"
+                    else
+                        printf "Key [MISSING]  "
+                        echo -e "${RED}FAIL${NC}"
+                        all_pass=false
+                    fi
+                done
+                unset IFS
+
+                echo ""
+                if [ "$all_pass" = "true" ]; then
+                    echo -e "${GREEN}All providers healthy${NC}"
+                else
+                    echo -e "${YELLOW}Some providers unavailable - failover chain may be limited${NC}"
+                fi
+                shift
+                ;;
+            --reset)
+                if [ -f "$failover_file" ]; then
+                    rm -f "$failover_file"
+                    echo "Failover state reset to defaults."
+                else
+                    echo "No failover state to reset."
+                fi
+                shift
+                ;;
+            --help|-h)
+                echo -e "${BOLD}loki failover${NC} - Cross-provider auto-failover management (v6.19.0)"
+                echo ""
+                echo "Usage: loki failover [options]"
+                echo ""
+                echo "Options:"
+                echo "  (no args)        Show failover status and health"
+                echo "  --enable         Enable auto-failover"
+                echo "  --disable        Disable auto-failover"
+                echo "  --chain X,Y,Z    Set failover chain (e.g., claude,codex,gemini)"
+                echo "  --test           Test all providers in chain"
+                echo "  --reset          Reset failover state to defaults"
+                echo "  --help, -h       Show this help"
+                echo ""
+                echo "Environment:"
+                echo "  LOKI_FAILOVER=true         Enable failover at startup"
+                echo "  LOKI_FAILOVER_CHAIN=X,Y,Z  Set default chain"
+                echo ""
+                echo "When a rate limit (429/529) is detected, Loki automatically switches"
+                echo "to the next healthy provider in the chain. After each successful"
+                echo "iteration on a fallback provider, the primary is health-checked and"
+                echo "execution switches back when it recovers."
+                return 0
+                ;;
+            *)
+                echo -e "${RED}Unknown option: $1${NC}"
+                echo "Run 'loki failover --help' for usage."
+                return 1
+                ;;
+        esac
+    done
+}
+
+# Dry-run PRD analysis and cost estimation (v6.18.0)
+cmd_plan() {
+    local prd_file=""
+    local show_json=false
+    local show_verbose=false
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                echo -e "${BOLD}loki plan${NC} - Dry-run PRD analysis and cost estimation"
+                echo ""
+                echo "Usage: loki plan <PRD> [options]"
+                echo ""
+                echo "Analyzes a PRD file without executing anything. Outputs complexity,"
+                echo "estimated iterations, token usage, cost, and execution plan."
+                echo ""
+                echo "Options:"
+                echo "  --json        Machine-readable JSON output"
+                echo "  --verbose     Show detailed per-iteration breakdown"
+                echo "  --help, -h    Show this help"
+                echo ""
+                echo "Examples:"
+                echo "  loki plan ./prd.md"
+                echo "  loki plan ./prd.md --json"
+                echo "  loki plan ./prd.md --verbose"
+                return 0
+                ;;
+            --json) show_json=true; shift ;;
+            --verbose) show_verbose=true; shift ;;
+            *)
+                if [ -z "$prd_file" ]; then
+                    prd_file="$1"
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    if [ -z "$prd_file" ]; then
+        echo -e "${RED}Usage: loki plan <PRD file>${NC}"
+        echo "Run 'loki plan --help' for usage."
+        return 1
+    fi
+
+    if [ ! -f "$prd_file" ]; then
+        echo -e "${RED}PRD file not found: $prd_file${NC}"
+        return 1
+    fi
+
+    local prd_path
+    prd_path="$(cd "$(dirname "$prd_file")" && pwd)/$(basename "$prd_file")"
+
+    python3 -c "
+import json, sys, os, re, math
+
+prd_path = sys.argv[1]
+show_json = sys.argv[2] == 'true'
+show_verbose = sys.argv[3] == 'true'
+
+# Colors (disabled for JSON mode)
+if show_json:
+    RED = GREEN = YELLOW = BLUE = CYAN = BOLD = DIM = NC = ''
+else:
+    RED = '\033[0;31m'
+    GREEN = '\033[0;32m'
+    YELLOW = '\033[1;33m'
+    BLUE = '\033[0;34m'
+    CYAN = '\033[0;36m'
+    BOLD = '\033[1m'
+    DIM = '\033[2m'
+    NC = '\033[0m'
+
+# --- Read and analyze PRD ---
+with open(prd_path, 'r') as f:
+    content = f.read()
+
+prd_words = len(content.split())
+prd_lines = content.count('\n') + 1
+
+# Detect PRD format
+is_json_prd = prd_path.endswith('.json')
+sections = []
+features = []
+endpoints = []
+integrations = []
+databases = []
+ui_components = []
+
+if is_json_prd:
+    try:
+        prd_data = json.loads(content)
+        features = prd_data.get('features', prd_data.get('requirements', []))
+        if isinstance(features, list):
+            features = [f.get('title', f.get('name', str(f))) if isinstance(f, dict) else str(f) for f in features]
+        else:
+            features = []
+    except Exception:
+        features = []
+else:
+    # Markdown analysis
+    for line in content.split('\n'):
+        stripped = line.strip()
+        if stripped.startswith('## '):
+            sections.append(stripped[3:].strip())
+        elif stripped.startswith('### '):
+            sections.append(stripped[4:].strip())
+
+    # Count features: headers + checkboxes
+    feature_patterns = re.findall(r'^(?:##?\s+|[-*]\s+\[.\]\s+)(.+)', content, re.MULTILINE)
+    features = feature_patterns
+
+    # Count API endpoints
+    endpoint_patterns = re.findall(
+        r'(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+[/\w{}:.-]+',
+        content, re.IGNORECASE
+    )
+    endpoints = endpoint_patterns
+
+    # Count external integrations
+    integration_keywords = [
+        'oauth', 'saml', 'oidc', 'stripe', 'twilio', 'sendgrid',
+        'aws', 'gcp', 'azure', 'firebase', 's3', 'redis', 'kafka',
+        'elasticsearch', 'rabbitmq', 'webhook', 'socket.io', 'websocket',
+        'graphql', 'grpc', 'docker', 'kubernetes', 'k8s'
+    ]
+    content_lower = content.lower()
+    for kw in integration_keywords:
+        if kw in content_lower:
+            integrations.append(kw)
+
+    # Count database mentions
+    db_keywords = ['postgresql', 'postgres', 'mysql', 'mongodb', 'sqlite',
+                   'dynamodb', 'cassandra', 'redis', 'prisma', 'typeorm',
+                   'sequelize', 'drizzle', 'knex', 'database', 'migration']
+    for kw in db_keywords:
+        if kw in content_lower:
+            databases.append(kw)
+
+    # Count UI components
+    ui_keywords = ['dashboard', 'form', 'table', 'modal', 'navbar',
+                   'sidebar', 'chart', 'graph', 'calendar', 'kanban',
+                   'drag.and.drop', 'responsive', 'mobile', 'animation']
+    for kw in ui_keywords:
+        if re.search(kw, content_lower):
+            ui_components.append(kw)
+
+feature_count = len(features)
+endpoint_count = len(endpoints)
+integration_count = len(integrations)
+db_count = len(databases)
+ui_count = len(ui_components)
+section_count = len(sections)
+
+# --- Determine complexity ---
+complexity_score = 0
+complexity_reasons = []
+
+if prd_words < 200 and feature_count < 5:
+    complexity = 'simple'
+    complexity_reasons.append('Short PRD (<200 words, <5 features)')
+elif prd_words > 3000 or feature_count > 30:
+    complexity_score += 3
+    complexity_reasons.append(f'Large PRD ({prd_words} words, {feature_count} features)')
+elif prd_words > 1000 or feature_count > 15:
+    complexity_score += 2
+    complexity_reasons.append(f'Medium PRD ({prd_words} words, {feature_count} features)')
+else:
+    complexity_score += 1
+    complexity_reasons.append(f'Standard PRD ({prd_words} words, {feature_count} features)')
+
+if endpoint_count > 20:
+    complexity_score += 2
+    complexity_reasons.append(f'{endpoint_count} API endpoints detected')
+elif endpoint_count > 5:
+    complexity_score += 1
+    complexity_reasons.append(f'{endpoint_count} API endpoints detected')
+
+if integration_count > 3:
+    complexity_score += 2
+    complexity_reasons.append(str(integration_count) + ' external integrations: ' + ', '.join(integrations[:5]))
+elif integration_count > 0:
+    complexity_score += 1
+    complexity_reasons.append(str(integration_count) + ' external integrations: ' + ', '.join(integrations))
+
+if db_count > 1:
+    complexity_score += 1
+    complexity_reasons.append('Multiple data stores: ' + ', '.join(databases[:4]))
+
+if ui_count > 5:
+    complexity_score += 1
+    complexity_reasons.append(f'{ui_count} UI components detected')
+
+# Map score to tier
+if complexity_score <= 1:
+    complexity = 'simple'
+elif complexity_score <= 3:
+    complexity = 'moderate'
+elif complexity_score <= 5:
+    complexity = 'complex'
+else:
+    complexity = 'enterprise'
+
+# --- Estimate iterations ---
+iteration_map = {
+    'simple': (3, 5),
+    'moderate': (6, 12),
+    'complex': (12, 24),
+    'enterprise': (24, 48),
+}
+min_iter, max_iter = iteration_map[complexity]
+
+# Adjust based on specific counts
+if endpoint_count > 10:
+    max_iter = max(max_iter, max_iter + endpoint_count // 5)
+if integration_count > 2:
+    max_iter += integration_count
+
+estimated_iterations = (min_iter + max_iter) // 2
+
+# --- Token estimation per iteration by RARV tier ---
+# RARV cycle: 4 iterations per cycle (plan, develop, develop, test)
+# Tokens estimated per iteration step
+tokens_per_tier = {
+    'planning': {'input': 50000, 'output': 8000, 'model': 'Opus'},
+    'development': {'input': 80000, 'output': 15000, 'model': 'Sonnet'},
+    'fast': {'input': 30000, 'output': 5000, 'model': 'Haiku'},
+}
+
+# Pricing per 1M tokens
+pricing = {
+    'Opus':   {'input': 15.00, 'output': 75.00},
+    'Sonnet': {'input': 3.00, 'output': 15.00},
+    'Haiku':  {'input': 0.25, 'output': 1.25},
+}
+
+# Build per-iteration plan
+iteration_plan = []
+total_input_tokens = 0
+total_output_tokens = 0
+total_cost = 0.0
+tier_totals = {'Opus': 0.0, 'Sonnet': 0.0, 'Haiku': 0.0}
+tier_iterations = {'Opus': 0, 'Sonnet': 0, 'Haiku': 0}
+
+for i in range(estimated_iterations):
+    rarv_step = i % 4
+    if rarv_step == 0:
+        tier = 'planning'
+        phase_label = 'Reason (Planning)'
+    elif rarv_step == 1:
+        tier = 'development'
+        phase_label = 'Act (Implementation)'
+    elif rarv_step == 2:
+        tier = 'development'
+        phase_label = 'Reflect (Review)'
+    else:
+        tier = 'fast'
+        phase_label = 'Verify (Testing)'
+
+    info = tokens_per_tier[tier]
+    model = info['model']
+    inp = info['input']
+    out = info['output']
+
+    cost = (inp / 1_000_000) * pricing[model]['input'] + \
+           (out / 1_000_000) * pricing[model]['output']
+
+    total_input_tokens += inp
+    total_output_tokens += out
+    total_cost += cost
+    tier_totals[model] += cost
+    tier_iterations[model] += 1
+
+    iteration_plan.append({
+        'iteration': i + 1,
+        'phase': phase_label,
+        'model': model,
+        'input_tokens': inp,
+        'output_tokens': out,
+        'cost_usd': round(cost, 4),
+    })
+
+# --- Execution plan (what each cycle tackles) ---
+execution_phases = []
+cycle_count = math.ceil(estimated_iterations / 4)
+phase_names = []
+
+# Generate phase names based on PRD content
+if sections:
+    phase_names = sections[:cycle_count]
+else:
+    # Generic phases based on complexity
+    generic = [
+        'Project setup and scaffolding',
+        'Core data models and database schema',
+        'API endpoints and business logic',
+        'Frontend components and pages',
+        'Authentication and authorization',
+        'External integrations',
+        'Testing and quality assurance',
+        'Performance optimization',
+        'Documentation and deployment',
+        'Edge cases and error handling',
+        'Security hardening',
+        'Final polish and review',
+    ]
+    phase_names = generic[:cycle_count]
+
+for idx, name in enumerate(phase_names):
+    execution_phases.append({
+        'cycle': idx + 1,
+        'iterations': f'{idx * 4 + 1}-{min((idx + 1) * 4, estimated_iterations)}',
+        'focus': name,
+    })
+
+# --- Time estimation ---
+# Average ~3.5 minutes per iteration (API calls + processing)
+minutes_per_iteration = 3.5
+total_minutes = estimated_iterations * minutes_per_iteration
+if total_minutes < 60:
+    time_estimate = f'{int(total_minutes)} minutes'
+elif total_minutes < 120:
+    time_estimate = f'{int(total_minutes // 60)} hour {int(total_minutes % 60)} minutes'
+else:
+    time_estimate = f'{total_minutes / 60:.1f} hours'
+
+min_time = min_iter * minutes_per_iteration
+max_time = max_iter * minutes_per_iteration
+
+# --- Quality gates ---
+quality_gates = [
+    {'gate': 'Static Analysis', 'trigger': 'Every iteration', 'applies': True},
+    {'gate': 'Unit Tests', 'trigger': 'Verify phase (every 4th iteration)', 'applies': True},
+    {'gate': 'Code Review (3-reviewer)', 'trigger': 'After implementation cycles', 'applies': complexity in ('complex', 'enterprise')},
+    {'gate': 'Anti-sycophancy Check', 'trigger': 'On unanimous review approval', 'applies': complexity in ('complex', 'enterprise')},
+    {'gate': 'Integration Tests', 'trigger': 'Mid-project and final', 'applies': integration_count > 0 or endpoint_count > 3},
+    {'gate': 'Coverage Gate (>80%)', 'trigger': 'Final verification', 'applies': True},
+    {'gate': 'Security Scan', 'trigger': 'Before completion', 'applies': integration_count > 0},
+    {'gate': 'Performance Benchmark', 'trigger': 'Before completion', 'applies': complexity in ('complex', 'enterprise')},
+    {'gate': 'Completion Council', 'trigger': 'After all phases', 'applies': True},
+]
+active_gates = [g for g in quality_gates if g['applies']]
+
+# --- Provider recommendation ---
+if integration_count > 3 or complexity in ('complex', 'enterprise'):
+    recommended_provider = 'Claude'
+    provider_reason = 'Full feature support needed (subagents, parallel, MCP)'
+elif complexity == 'simple' and endpoint_count == 0:
+    recommended_provider = 'Any (Claude/Codex/Gemini)'
+    provider_reason = 'Simple project works with all providers'
+else:
+    recommended_provider = 'Claude'
+    provider_reason = 'Best iteration quality and tool support'
+
+# --- Output ---
+if show_json:
+    result = {
+        'prd_file': prd_path,
+        'prd_stats': {
+            'words': prd_words,
+            'lines': prd_lines,
+            'sections': section_count,
+            'features': feature_count,
+            'endpoints': endpoint_count,
+            'integrations': integrations,
+            'databases': databases,
+            'ui_components': ui_count,
+        },
+        'complexity': {
+            'tier': complexity,
+            'score': complexity_score,
+            'reasons': complexity_reasons,
+        },
+        'iterations': {
+            'estimated': estimated_iterations,
+            'range': [min_iter, max_iter],
+            'rarv_cycles': cycle_count,
+        },
+        'tokens': {
+            'total_input': total_input_tokens,
+            'total_output': total_output_tokens,
+            'total': total_input_tokens + total_output_tokens,
+        },
+        'cost': {
+            'total_usd': round(total_cost, 2),
+            'by_model': {k: round(v, 2) for k, v in tier_totals.items()},
+            'iterations_by_model': tier_iterations,
+        },
+        'time': {
+            'estimated': time_estimate,
+            'minutes': round(total_minutes, 1),
+            'range_minutes': [round(min_time, 1), round(max_time, 1)],
+        },
+        'execution_plan': execution_phases,
+        'quality_gates': [g['gate'] for g in active_gates],
+        'provider': {
+            'recommended': recommended_provider,
+            'reason': provider_reason,
+        },
+    }
+    if show_verbose:
+        result['iteration_details'] = iteration_plan
+    print(json.dumps(result, indent=2))
+    sys.exit(0)
+
+# --- Formatted output ---
+print()
+print(f'{BOLD}PRD Analysis: {os.path.basename(prd_path)}{NC}')
+print(f'{DIM}' + '=' * 60 + f'{NC}')
+
+# PRD Stats
+print(f'\n{CYAN}PRD Statistics{NC}')
+print(f'  Words: {prd_words}  |  Lines: {prd_lines}  |  Sections: {section_count}')
+print(f'  Features: {feature_count}  |  Endpoints: {endpoint_count}  |  Integrations: {integration_count}')
+if databases:
+    print('  Data stores: ' + ', '.join(databases[:4]))
+if ui_count > 0:
+    print(f'  UI components: {ui_count}')
+
+# Complexity
+color = {'simple': GREEN, 'moderate': YELLOW, 'complex': RED, 'enterprise': RED}
+cx_color = color.get(complexity, NC)
+print(f'\n{CYAN}Complexity{NC}')
+print(f'  Tier: {cx_color}{BOLD}{complexity.upper()}{NC} (score: {complexity_score})')
+for reason in complexity_reasons:
+    print(f'  {DIM}- {reason}{NC}')
+
+# Iterations
+print(f'\n{CYAN}Estimated Iterations{NC}')
+print(f'  Count: {BOLD}{estimated_iterations}{NC} (range: {min_iter}-{max_iter})')
+print(f'  RARV cycles: {cycle_count} (4 iterations per cycle)')
+opus_n = tier_iterations.get('Opus', 0)
+sonnet_n = tier_iterations.get('Sonnet', 0)
+haiku_n = tier_iterations.get('Haiku', 0)
+print(f'  Model distribution: Opus x{opus_n} | Sonnet x{sonnet_n} | Haiku x{haiku_n}')
+
+# Tokens
+total_tok = total_input_tokens + total_output_tokens
+print(f'\n{CYAN}Token Usage Estimate{NC}')
+print(f'  Input:  {total_input_tokens:>12,} tokens')
+print(f'  Output: {total_output_tokens:>12,} tokens')
+print(f'  Total:  {total_tok:>12,} tokens')
+
+# Cost
+ds = chr(36)  # dollar sign
+print(f'\n{CYAN}Cost Estimate{NC}')
+print(f'  {BOLD}Total: {ds}{total_cost:.2f}{NC}')
+for model in ['Opus', 'Sonnet', 'Haiku']:
+    pct = (tier_totals[model] / total_cost * 100) if total_cost > 0 else 0
+    bar_len = int(pct / 5)
+    bar = '#' * bar_len + '.' * (20 - bar_len)
+    mc = tier_totals[model]
+    print('  {:>6}: {}{:>7.2f} ({:4.1f}%) [{}]'.format(model, ds, mc, pct, bar))
+
+# Time
+print(f'\n{CYAN}Time Estimate{NC}')
+print(f'  Estimated: {BOLD}{time_estimate}{NC}')
+min_t_str = f'{int(min_time)} min' if min_time < 60 else f'{min_time/60:.1f} hr'
+max_t_str = f'{int(max_time)} min' if max_time < 60 else f'{max_time/60:.1f} hr'
+print(f'  Range: {min_t_str} - {max_t_str}')
+
+# Execution plan
+print(f'\n{CYAN}Execution Plan{NC}')
+for phase in execution_phases:
+    c_num = phase.get('cycle', '')
+    c_iters = phase.get('iterations', '')
+    c_focus = phase.get('focus', '')
+    print(f'  {BOLD}Cycle {c_num}{NC} (iterations {c_iters}): {c_focus}')
+
+# Quality gates
+print(f'\n{CYAN}Quality Gates ({len(active_gates)} active){NC}')
+for g in active_gates:
+    g_name = g.get('gate', '')
+    g_trig = g.get('trigger', '')
+    print(f'  {GREEN}[*]{NC} {g_name} -- {DIM}{g_trig}{NC}')
+
+# Provider recommendation
+print(f'\n{CYAN}Recommended Provider{NC}')
+print(f'  {BOLD}{recommended_provider}{NC}')
+print(f'  {DIM}{provider_reason}{NC}')
+
+# Verbose: per-iteration breakdown
+if show_verbose:
+    print(f'\n{CYAN}Per-Iteration Breakdown{NC}')
+    hdr = '  ' + DIM + '{:>4}  {:<24} {:<7} {:>8} {:>8} {:>8}'.format('Iter', 'Phase', 'Model', 'Input', 'Output', 'Cost') + NC
+    print(hdr)
+    print('  ' + DIM + '-' * 65 + NC)
+    for it in iteration_plan:
+        i_num = it.get('iteration', 0)
+        i_phase = it.get('phase', '')
+        i_model = it.get('model', '')
+        i_inp = it.get('input_tokens', 0)
+        i_out = it.get('output_tokens', 0)
+        i_cost = it.get('cost_usd', 0)
+        print('  {:>4}  {:<24} {:<7} {:>7,} {:>7,} {}{:>6.2f}'.format(i_num, i_phase, i_model, i_inp, i_out, ds, i_cost))
+
+print(f'\n{DIM}This is an estimate. Actual usage depends on PRD complexity,')
+print(f'code review cycles, and test failures.{NC}')
+print()
+" "$prd_path" "$show_json" "$show_verbose"
+}
+
 # Main command dispatcher
 main() {
     if [ $# -eq 0 ]; then
@@ -8461,6 +9183,12 @@ main() {
         trigger)
             cmd_trigger "$@"
             ;;
+        plan)
+            cmd_plan "$@"
+            ;;
+        failover)
+            cmd_failover "$@"
+            ;;
         version|--version|-v)
             cmd_version
             ;;

package/autonomy/run.sh

@@ -6525,6 +6525,278 @@ calculate_wait() {
     echo $wait_time
 }
 
+#===============================================================================
+# Cross-Provider Auto-Failover (v6.19.0)
+#===============================================================================
+
+# Initialize failover state file on startup
+init_failover_state() {
+    local failover_dir="${TARGET_DIR:-.}/.loki/state"
+    local failover_file="$failover_dir/failover.json"
+
+    # Only create if failover is enabled via env or config
+    if [ "${LOKI_FAILOVER:-false}" != "true" ]; then
+        return
+    fi
+
+    mkdir -p "$failover_dir"
+
+    if [ ! -f "$failover_file" ]; then
+        local chain="${LOKI_FAILOVER_CHAIN:-claude,codex,gemini}"
+        local primary="${PROVIDER_NAME:-claude}"
+        cat > "$failover_file" << FEOF
+{
+  "enabled": true,
+  "chain": $(printf '%s' "$chain" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read().strip().split(",")))' 2>/dev/null || echo '["claude","codex","gemini"]'),
+  "currentProvider": "$primary",
+  "primaryProvider": "$primary",
+  "lastFailover": null,
+  "failoverCount": 0,
+  "healthCheck": {
+    "$primary": "healthy"
+  }
+}
+FEOF
+        log_info "Failover initialized: chain=$chain, primary=$primary"
+    fi
+}
+
+# Read failover config from state file
+# Sets: FAILOVER_ENABLED, FAILOVER_CHAIN, FAILOVER_CURRENT, FAILOVER_PRIMARY
+read_failover_config() {
+    local failover_file="${TARGET_DIR:-.}/.loki/state/failover.json"
+
+    if [ ! -f "$failover_file" ]; then
+        FAILOVER_ENABLED="false"
+        return 1
+    fi
+
+    eval "$(python3 << 'PYEOF' 2>/dev/null || echo 'FAILOVER_ENABLED=false'
+import json, os
+try:
+    with open(os.path.join(os.environ.get('TARGET_DIR', '.'), '.loki/state/failover.json')) as f:
+        d = json.load(f)
+    chain = ','.join(d.get('chain', ['claude','codex','gemini']))
+    print(f'FAILOVER_ENABLED={str(d.get("enabled", False)).lower()}')
+    print(f'FAILOVER_CHAIN="{chain}"')
+    print(f'FAILOVER_CURRENT="{d.get("currentProvider", "claude")}"')
+    print(f'FAILOVER_PRIMARY="{d.get("primaryProvider", "claude")}"')
+    print(f'FAILOVER_COUNT={d.get("failoverCount", 0)}')
+except Exception:
+    print('FAILOVER_ENABLED=false')
+PYEOF
+    )"
+}
+
+# Update failover state file
+update_failover_state() {
+    local key="$1"
+    local value="$2"
+    local failover_file="${TARGET_DIR:-.}/.loki/state/failover.json"
+
+    [ ! -f "$failover_file" ] && return 1
+
+    python3 << PYEOF 2>/dev/null || true
+import json, os
+fpath = os.path.join(os.environ.get('TARGET_DIR', '.'), '.loki/state/failover.json')
+try:
+    with open(fpath) as f:
+        d = json.load(f)
+    key = "$key"
+    value = "$value"
+    # Handle type conversion
+    if value == "null":
+        d[key] = None
+    elif value == "true":
+        d[key] = True
+    elif value == "false":
+        d[key] = False
+    elif value.isdigit():
+        d[key] = int(value)
+    else:
+        d[key] = value
+    with open(fpath, 'w') as f:
+        json.dump(d, f, indent=2)
+except Exception:
+    pass
+PYEOF
+}
+
+# Update health status for a specific provider in failover.json
+update_failover_health() {
+    local provider="$1"
+    local status="$2"  # healthy, unhealthy, unknown
+    local failover_file="${TARGET_DIR:-.}/.loki/state/failover.json"
+
+    [ ! -f "$failover_file" ] && return 1
+
+    python3 << PYEOF 2>/dev/null || true
+import json, os
+fpath = os.path.join(os.environ.get('TARGET_DIR', '.'), '.loki/state/failover.json')
+try:
+    with open(fpath) as f:
+        d = json.load(f)
+    if 'healthCheck' not in d:
+        d['healthCheck'] = {}
+    d['healthCheck']["$provider"] = "$status"
+    with open(fpath, 'w') as f:
+        json.dump(d, f, indent=2)
+except Exception:
+    pass
+PYEOF
+}
+
+# Check provider health: API key exists + CLI installed
+# Returns: 0 if healthy, 1 if unhealthy
+check_provider_health() {
+    local provider="$1"
+
+    # Check CLI is installed
+    case "$provider" in
+        claude)
+            command -v claude &>/dev/null || return 1
+            [ -n "${ANTHROPIC_API_KEY:-}" ] || return 1
+            ;;
+        codex)
+            command -v codex &>/dev/null || return 1
+            [ -n "${OPENAI_API_KEY:-}" ] || return 1
+            ;;
+        gemini)
+            command -v gemini &>/dev/null || return 1
+            [ -n "${GOOGLE_API_KEY:-${GEMINI_API_KEY:-}}" ] || return 1
+            ;;
+        cline)
+            command -v cline &>/dev/null || return 1
+            ;;
+        aider)
+            command -v aider &>/dev/null || return 1
+            ;;
+        *)
+            return 1
+            ;;
+    esac
+
+    return 0
+}
+
+# Attempt failover to next healthy provider in chain
+# Called when rate limit is detected on current provider
+# Returns: 0 if failover succeeded, 1 if all providers exhausted
+attempt_provider_failover() {
+    read_failover_config || return 1
+
+    if [ "$FAILOVER_ENABLED" != "true" ]; then
+        return 1
+    fi
+
+    local current="${FAILOVER_CURRENT:-${PROVIDER_NAME:-claude}}"
+    log_warn "Failover: rate limit on $current, checking chain: $FAILOVER_CHAIN"
+
+    # Mark current as unhealthy
+    update_failover_health "$current" "unhealthy"
+
+    # Walk the chain looking for the next healthy provider
+    local IFS=','
+    local found_current=false
+    local tried_wrap=false
+
+    # Two passes: first from current position to end, then from start to current
+    for provider in $FAILOVER_CHAIN $FAILOVER_CHAIN; do
+        if [ "$provider" = "$current" ]; then
+            if [ "$found_current" = "true" ]; then
+                # We've wrapped around, all exhausted
+                break
+            fi
+            found_current=true
+            continue
+        fi
+
+        [ "$found_current" != "true" ] && continue
+
+        # Check if this provider is healthy
+        if check_provider_health "$provider"; then
+            log_info "Failover: switching from $current to $provider"
+
+            # Load the new provider config
+            local provider_dir
+            provider_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/providers"
+            if [ -f "$provider_dir/$provider.sh" ]; then
+                source "$provider_dir/$provider.sh"
+            fi
+
+            # Update state
+            update_failover_state "currentProvider" "$provider"
+            update_failover_state "lastFailover" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+            update_failover_state "failoverCount" "$((FAILOVER_COUNT + 1))"
+            update_failover_health "$provider" "healthy"
+
+            # Update runtime provider vars
+            PROVIDER_NAME="$provider"
+
+            emit_event_json "provider_failover" \
+                "from=$current" \
+                "to=$provider" \
+                "reason=rate_limit" \
+                "iteration=$ITERATION_COUNT" 2>/dev/null || true
+
+            log_info "Failover: now using $provider (failover #$((FAILOVER_COUNT + 1)))"
+            return 0
+        else
+            log_debug "Failover: $provider is unhealthy, skipping"
+            update_failover_health "$provider" "unhealthy"
+        fi
+    done
+
+    log_warn "Failover: all providers in chain exhausted, falling back to retry"
+    return 1
+}
+
+# Check if primary provider has recovered after running on a fallback
+# Called after each successful iteration when on a non-primary provider
+# Returns: 0 if switched back to primary, 1 if still on fallback
+check_primary_recovery() {
+    read_failover_config || return 1
+
+    if [ "$FAILOVER_ENABLED" != "true" ]; then
+        return 1
+    fi
+
+    local current="${FAILOVER_CURRENT:-${PROVIDER_NAME:-claude}}"
+    local primary="${FAILOVER_PRIMARY:-claude}"
+
+    # Already on primary
+    if [ "$current" = "$primary" ]; then
+        return 1
+    fi
+
+    # Check if primary is healthy again
+    if check_provider_health "$primary"; then
+        log_info "Failover: primary provider $primary appears healthy, switching back"
+
+        # Load primary provider config
+        local provider_dir
+        provider_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/providers"
+        if [ -f "$provider_dir/$primary.sh" ]; then
+            source "$provider_dir/$primary.sh"
+        fi
+
+        update_failover_state "currentProvider" "$primary"
+        update_failover_health "$primary" "healthy"
+
+        PROVIDER_NAME="$primary"
+
+        emit_event_json "provider_recovery" \
+            "from=$current" \
+            "to=$primary" \
+            "iteration=$ITERATION_COUNT" 2>/dev/null || true
+
+        log_info "Failover: recovered to primary provider $primary"
+        return 0
+    fi
+
+    return 1
+}
+
 #===============================================================================
 # Rate Limit Detection
 #===============================================================================
@@ -8145,6 +8417,9 @@ run_autonomous() {
     load_state
     local retry=$RETRY_COUNT
 
+    # Initialize Cross-Provider Failover (v6.19.0)
+    init_failover_state
+
     # Initialize Completion Council (v5.25.0)
     if type council_init &>/dev/null; then
         council_init "$prd_path"
@@ -8784,6 +9059,9 @@ if __name__ == "__main__":
                 log_warn "Council will evaluate at next check interval (every ${COUNCIL_CHECK_INTERVAL:-5} iterations)"
             fi
 
+            # Cross-provider failover: check if primary has recovered (v6.19.0)
+            check_primary_recovery 2>/dev/null || true
+
             # SUCCESS exit - continue IMMEDIATELY to next iteration (no wait!)
             log_step "Starting next iteration..."
             ((retry++))
@@ -8801,6 +9079,13 @@ if __name__ == "__main__":
         local wait_time
 
         if [ $rate_limit_wait -gt 0 ]; then
+            # Cross-provider failover (v6.19.0): try switching provider before waiting
+            if attempt_provider_failover 2>/dev/null; then
+                log_info "Failover succeeded - retrying immediately with ${PROVIDER_NAME}"
+                ((retry++))
+                continue
+            fi
+
             wait_time=$rate_limit_wait
             local human_time=$(format_duration $wait_time)
             log_warn "Rate limit detected! Waiting until reset (~$human_time)..."

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "6.17.2"
+__version__ = "6.19.0"
 
 # Expose the control app for easy import
 try:

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v6.17.2
+**Version:** v6.19.0
 
 ---
 

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '6.17.2'
+__version__ = '6.19.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "6.17.2",
+  "version": "6.19.0",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",