loki-mode 6.17.1 → 6.18.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.1
+# Loki Mode v6.18.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.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.18.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.17.1
+6.18.0

package/autonomy/loki

@@ -401,6 +401,7 @@ show_help() {
     echo "  pause            Pause after current session"
     echo "  resume           Resume paused execution"
     echo "  status [--json]  Show current status (--json for machine-readable)"
+    echo "  stats [flags]    Session statistics (--json, --efficiency)"
     echo "  logs             Show recent log output"
     echo "  dashboard [cmd]  Dashboard server (start|stop|status|url|open)"
     echo "  provider [cmd]   Manage AI provider (show|set|list|info)"
@@ -434,6 +435,7 @@ 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 "  plan <PRD>       Dry-run PRD analysis: complexity, cost, and execution plan"
     echo "  version          Show version"
     echo "  help             Show this help"
     echo ""
@@ -1713,6 +1715,293 @@ print(json.dumps(result, indent=2))
     fi
 }
 
+# Session statistics
+cmd_stats() {
+    local show_json=false
+    local show_efficiency=false
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --json) show_json=true; shift ;;
+            --efficiency) show_efficiency=true; shift ;;
+            *) shift ;;
+        esac
+    done
+
+    if [ ! -d "$LOKI_DIR" ]; then
+        if [ "$show_json" = true ]; then
+            echo '{"error": "No active session"}'
+        else
+            echo -e "${YELLOW}No active session found.${NC}"
+            echo "Start a session with: loki start <prd>"
+        fi
+        return 0
+    fi
+
+    local loki_dir="$LOKI_DIR"
+    local eff_flag="$show_efficiency"
+    local json_flag="$show_json"
+
+    python3 -c "
+import json, os, sys, glob
+
+loki_dir = sys.argv[1]
+show_efficiency = sys.argv[2] == 'true'
+show_json = sys.argv[3] == 'true'
+
+# --- Gather data ---
+
+# Session state (orchestrator)
+phase = 'N/A'
+iteration_count = 0
+orch_file = os.path.join(loki_dir, 'state', 'orchestrator.json')
+if os.path.isfile(orch_file):
+    try:
+        with open(orch_file) as f:
+            orch = json.load(f)
+        phase = orch.get('currentPhase', 'N/A')
+        iteration_count = orch.get('currentIteration', 0)
+    except Exception:
+        pass
+
+# Per-iteration metrics
+eff_dir = os.path.join(loki_dir, 'metrics', 'efficiency')
+iterations = []
+if os.path.isdir(eff_dir):
+    for path in sorted(glob.glob(os.path.join(eff_dir, 'iteration-*.json'))):
+        try:
+            with open(path) as f:
+                iterations.append(json.load(f))
+        except Exception:
+            pass
+
+# If we have iteration files, use their count (more accurate)
+if iterations:
+    iteration_count = max(iteration_count, len(iterations))
+
+total_input = sum(it.get('input_tokens', 0) for it in iterations)
+total_output = sum(it.get('output_tokens', 0) for it in iterations)
+total_tokens = total_input + total_output
+total_cost = sum(it.get('cost_usd', 0) for it in iterations)
+total_duration = sum(it.get('duration_seconds', 0) for it in iterations)
+
+# Budget
+budget_limit = 0
+budget_used = 0
+budget_file = os.path.join(loki_dir, 'metrics', 'budget.json')
+if os.path.isfile(budget_file):
+    try:
+        with open(budget_file) as f:
+            bd = json.load(f)
+        budget_limit = bd.get('budget_limit', 0)
+        budget_used = bd.get('budget_used', 0)
+    except Exception:
+        pass
+
+# Quality gates
+gates_passed = 0
+gates_total = 0
+gates_file = os.path.join(loki_dir, 'state', 'quality-gates.json')
+if os.path.isfile(gates_file):
+    try:
+        with open(gates_file) as f:
+            gates = json.load(f)
+        if isinstance(gates, dict):
+            for k, v in gates.items():
+                if isinstance(v, dict):
+                    gates_total += 1
+                    if v.get('passed') or v.get('status') == 'passed':
+                        gates_passed += 1
+                elif isinstance(v, bool):
+                    gates_total += 1
+                    if v:
+                        gates_passed += 1
+        elif isinstance(gates, list):
+            for g in gates:
+                gates_total += 1
+                if isinstance(g, dict) and (g.get('passed') or g.get('status') == 'passed'):
+                    gates_passed += 1
+                elif g is True:
+                    gates_passed += 1
+    except Exception:
+        pass
+
+# Gate failures
+gate_failures = {}
+gf_file = os.path.join(loki_dir, 'quality', 'gate-failure-count.json')
+if os.path.isfile(gf_file):
+    try:
+        with open(gf_file) as f:
+            gate_failures = json.load(f)
+        if not isinstance(gate_failures, dict):
+            gate_failures = {}
+    except Exception:
+        pass
+
+# Code reviews
+reviews_total = 0
+reviews_approved = 0
+reviews_revision = 0
+quality_dir = os.path.join(loki_dir, 'quality')
+if os.path.isdir(quality_dir):
+    for fname in os.listdir(quality_dir):
+        if not fname.endswith('.json') or fname == 'gate-failure-count.json':
+            continue
+        fpath = os.path.join(quality_dir, fname)
+        try:
+            with open(fpath) as f:
+                rev = json.load(f)
+            if isinstance(rev, dict) and ('verdict' in rev or 'approved' in rev or 'reviewers' in rev):
+                reviews_total += 1
+                verdict = rev.get('verdict', '').lower()
+                if rev.get('approved') or verdict in ('approved', 'approve', 'pass'):
+                    reviews_approved += 1
+                elif verdict in ('revision', 'revise', 'changes_requested', 'reject'):
+                    reviews_revision += 1
+        except Exception:
+            pass
+
+# --- Format duration helper ---
+def fmt_duration(secs):
+    secs = int(secs)
+    if secs < 60:
+        return f'{secs}s'
+    hours = secs // 3600
+    mins = (secs % 3600) // 60
+    secs_rem = secs % 60
+    if hours > 0:
+        return f'{hours}h {mins:02d}m'
+    return f'{mins}m {secs_rem:02d}s'
+
+def fmt_number(n):
+    return f'{n:,}'
+
+# --- JSON output ---
+if show_json:
+    output = {
+        'session': {
+            'iterations': iteration_count,
+            'duration_seconds': total_duration,
+            'phase': phase
+        },
+        'tokens': {
+            'input': total_input,
+            'output': total_output,
+            'total': total_tokens,
+            'cost_usd': round(total_cost, 2)
+        },
+        'quality': {
+            'gates_passed': gates_passed,
+            'gates_total': gates_total,
+            'reviews_total': reviews_total,
+            'reviews_approved': reviews_approved,
+            'reviews_revision': reviews_revision,
+            'gate_failures': gate_failures
+        },
+        'efficiency': {
+            'avg_tokens_per_iteration': round(total_tokens / iteration_count) if iteration_count > 0 else 0,
+            'avg_cost_per_iteration': round(total_cost / iteration_count, 2) if iteration_count > 0 else 0,
+            'avg_duration_per_iteration': round(total_duration / iteration_count, 1) if iteration_count > 0 else 0
+        },
+        'budget': {
+            'used': round(budget_used, 2),
+            'limit': budget_limit,
+            'percent': round((budget_used / budget_limit) * 100, 1) if budget_limit > 0 else 0
+        }
+    }
+    if show_efficiency:
+        output['iterations'] = []
+        for i, it in enumerate(iterations, 1):
+            output['iterations'].append({
+                'number': i,
+                'input_tokens': it.get('input_tokens', 0),
+                'output_tokens': it.get('output_tokens', 0),
+                'cost_usd': round(it.get('cost_usd', 0), 2),
+                'duration_seconds': it.get('duration_seconds', 0)
+            })
+    print(json.dumps(output, indent=2))
+    sys.exit(0)
+
+# --- Text output ---
+print('Loki Mode Session Statistics')
+print('============================')
+print()
+
+# Session
+print('Session')
+print(f'  Iterations completed: {iteration_count}')
+print(f'  Duration: {fmt_duration(total_duration)}')
+print(f'  Current phase: {phase}')
+print()
+
+# Token Usage
+print('Token Usage')
+if iterations:
+    print(f'  Input tokens:  {fmt_number(total_input)}')
+    print(f'  Output tokens: {fmt_number(total_output)}')
+    print(f'  Total tokens:  {fmt_number(total_tokens)}')
+    print(f'  Estimated cost: \${total_cost:.2f}')
+else:
+    print('  N/A (no iteration metrics found)')
+print()
+
+# Quality Gates
+print('Quality Gates')
+if gates_total > 0:
+    pct = round((gates_passed / gates_total) * 100) if gates_total > 0 else 0
+    print(f'  Gates passed: {gates_passed}/{gates_total} ({pct}%)')
+else:
+    print('  Gates passed: N/A')
+if reviews_total > 0:
+    parts = []
+    if reviews_approved > 0:
+        parts.append(f'{reviews_approved} approved')
+    if reviews_revision > 0:
+        parts.append(f'{reviews_revision} revision requested')
+    detail = ', '.join(parts) if parts else 'N/A'
+    print(f'  Code reviews: {reviews_total} ({detail})')
+if gate_failures:
+    failure_parts = [f'{k} ({v})' for k, v in gate_failures.items() if v > 0]
+    if failure_parts:
+        print(f'  Gate failures: {', '.join(failure_parts)}')
+print()
+
+# Efficiency
+print('Efficiency')
+if iteration_count > 0 and iterations:
+    avg_tokens = round(total_tokens / iteration_count)
+    avg_cost = total_cost / iteration_count
+    avg_dur = total_duration / iteration_count
+    print(f'  Avg tokens/iteration: {fmt_number(avg_tokens)}')
+    print(f'  Avg cost/iteration: \${avg_cost:.2f}')
+    print(f'  Avg duration/iteration: {fmt_duration(avg_dur)}')
+else:
+    print('  N/A (no iteration metrics found)')
+print()
+
+# Budget
+print('Budget')
+if budget_limit > 0:
+    pct = round((budget_used / budget_limit) * 100, 1)
+    print(f'  Used: \${budget_used:.2f} / \${budget_limit:.2f} ({pct}%)')
+elif budget_used > 0:
+    print(f'  Used: \${budget_used:.2f} (no limit set)')
+else:
+    print('  N/A')
+
+# Per-iteration breakdown
+if show_efficiency and iterations:
+    print()
+    print('Per-Iteration Breakdown')
+    for i, it in enumerate(iterations, 1):
+        inp = fmt_number(it.get('input_tokens', 0))
+        out = fmt_number(it.get('output_tokens', 0))
+        cost = it.get('cost_usd', 0)
+        dur = fmt_duration(it.get('duration_seconds', 0))
+        print(f'  #{i:<3} input: {inp:<10} output: {out:<10} cost: \${cost:.2f}  time: {dur}')
+" "$loki_dir" "$eff_flag" "$json_flag"
+}
+
 # Provider management
 cmd_provider() {
     local subcommand="${1:-show}"
@@ -8010,6 +8299,507 @@ for line in sys.stdin:
     esac
 }
 
+# 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
@@ -8053,6 +8843,9 @@ main() {
         status)
             cmd_status "$@"
             ;;
+        stats)
+            cmd_stats "$@"
+            ;;
         dashboard)
             cmd_dashboard "$@"
             ;;
@@ -8170,6 +8963,9 @@ main() {
         trigger)
             cmd_trigger "$@"
             ;;
+        plan)
+            cmd_plan "$@"
+            ;;
         version|--version|-v)
             cmd_version
             ;;

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "6.17.1"
+__version__ = "6.18.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.1
+**Version:** v6.18.0
 
 ---
 

package/mcp/__init__.py

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

package/package.json

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