vigthoria-cli 1.8.19 → 1.9.2

package/dist/commands/legion.js

@@ -9,12 +9,48 @@
  *   vigthoria legion --workers          List available Legion workers
  *   vigthoria legion --status           Show Legion infrastructure status
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LegionCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline/promises"));
 const logger_js_1 = require("../utils/logger.js");
 const api_js_1 = require("../utils/api.js");
 // Hyper Loop / Legion runs on the Vigthoria backend only. Local user installs
@@ -42,8 +78,30 @@ class LegionCommand {
         this.config = config;
         this.logger = logger;
     }
+    getHyperloopUrls() {
+        const urls = new Set();
+        const configuredApiUrl = String(this.config.get('apiUrl') || '').trim().replace(/\/$/, '');
+        if (configuredApiUrl) {
+            urls.add(`${configuredApiUrl}/api/hyperloop`);
+        }
+        const envUrl = String(process.env.VIGTHORIA_HYPERLOOP_URL || '').trim().replace(/\/$/, '');
+        if (envUrl) {
+            urls.add(envUrl);
+        }
+        if ((0, api_js_1.isServerRuntime)()) {
+            for (const internal of buildServerHyperloopUrls()) {
+                urls.add(internal.replace(/\/$/, ''));
+            }
+        }
+        return Array.from(urls);
+    }
     getHeaders() {
         const headers = { 'Content-Type': 'application/json' };
+        const serviceKey = this.getLegionServiceKey();
+        if (serviceKey) {
+            headers['X-Service-Key'] = serviceKey;
+            return headers;
+        }
         const token = this.config.get('authToken');
         if (token) {
             headers['Authorization'] = `Bearer ${token}`;
@@ -51,7 +109,46 @@ class LegionCommand {
         }
         return headers;
     }
+    async readJsonResponse(response, context) {
+        try {
+            return await response.json();
+        }
+        catch (err) {
+            (0, api_js_1.propagateError)({
+                ...((err && typeof err === 'object') ? err : { message: String(err) }),
+                message: `${context} returned invalid JSON: ${err?.message || String(err)}`,
+                statusCode: response.status,
+                commandName: 'legion',
+                endpoint: response.url || context,
+                details: {
+                    ...((err?.details && typeof err.details === 'object') ? err.details : {}),
+                    command: 'legion',
+                    endpoint: response.url || context,
+                    context,
+                    status: response.status,
+                },
+            });
+        }
+    }
+    propagateLegionApiError(context, endpoint, err) {
+        const original = err && typeof err === 'object' ? err : { message: String(err) };
+        (0, api_js_1.propagateError)({
+            ...original,
+            commandName: 'legion',
+            endpoint: original.endpoint || original?.config?.url || original?.details?.endpoint || endpoint || context,
+            details: {
+                ...(original.details && typeof original.details === 'object' ? original.details : {}),
+                command: 'legion',
+                endpoint: original.endpoint || original?.config?.url || original?.details?.endpoint || endpoint || context,
+                context,
+            },
+        });
+    }
     async run(request, options) {
+        if (options.godmode) {
+            await this.runGodmode(request, options);
+            return;
+        }
         if (options.workers) {
             await this.showWorkers();
             return;
@@ -64,99 +161,922 @@ class LegionCommand {
             console.log(chalk_1.default.yellow('Usage: vigthoria legion "<task description>"'));
             console.log(chalk_1.default.gray('  --workers     List available Legion workers'));
             console.log(chalk_1.default.gray('  --status      Show Legion infrastructure status'));
+            console.log(chalk_1.default.gray('  --godmode     Run calculator + high-intelligence orchestration'));
             return;
         }
         await this.planAndExecute(request, options);
     }
-    async planAndExecute(request, options) {
-        const spinner = (0, logger_js_1.createSpinner)('Submitting to Legion parallel orchestrator...').start();
-        const body = {
+    async runGodmode(request, options) {
+        if (!request) {
+            console.log(chalk_1.default.yellow('Usage: vigthoria legion --godmode "<task description>"'));
+            console.log(chalk_1.default.gray('  --plan-only      Run calculator only (no execution)'));
+            console.log(chalk_1.default.gray('  --approve        Skip confirmation prompt and execute'));
+            console.log(chalk_1.default.gray('  --auto-charge    Attempt direct VigCoin top-up when balance is low'));
+            console.log(chalk_1.default.gray('  --timeout <sec>  Abort remote execution if no result within timeout (default: 120)'));
+            return;
+        }
+        const workspace = options.project || process.cwd();
+        const scan = this.scanProject(workspace);
+        const selectedModels = this.resolveModelProfiles(options.models);
+        const quote = this.buildRoleQuote(scan, selectedModels);
+        const billingQuote = this.buildBillingQuote(quote);
+        let billingGate = await this.evaluateBillingGate(billingQuote);
+        this.printGodmodeQuote(workspace, scan, quote, billingQuote, billingGate);
+        if (options.planOnly) {
+            console.log(chalk_1.default.green('Godmode calculator complete (plan-only).'));
+            return;
+        }
+        if (!billingGate.canProceed) {
+            const resolved = await this.resolveBillingInsufficientFunds(billingQuote, billingGate, options);
+            if (!resolved) {
+                console.log(chalk_1.default.yellow('Godmode cancelled due to insufficient VigCoin balance.'));
+                return;
+            }
+            billingGate = await this.evaluateBillingGate(billingQuote);
+            if (!billingGate.canProceed) {
+                this.printBillingGateSummary(billingQuote, billingGate);
+                console.log(chalk_1.default.red('Billing gate still blocked after charge attempt.'));
+                return;
+            }
+        }
+        const autoApprove = options.approve === true && options.noApprove !== true;
+        const approved = autoApprove ? true : await this.confirmExecution();
+        if (!approved) {
+            console.log(chalk_1.default.yellow('Godmode cancelled by user.'));
+            return;
+        }
+        const charged = await this.collectExecutionCharge(billingQuote, billingGate);
+        if (!charged) {
+            console.log(chalk_1.default.yellow('Godmode cancelled because wallet charge was not completed.'));
+            return;
+        }
+        const enrichedRequest = [
+            '[GODMODE EXECUTION]',
             request,
-            context: {
-                workspace: options.project || process.cwd(),
+            `Workspace: ${workspace}`,
+            `PhaseA: files=${scan.files}, lines=${scan.lines}, import_edges=${scan.importEdges}`,
+            'Role model assignment:',
+            ...quote.map((q) => `- ${q.role}: ${q.model} (requested_model=${q.requestedModel})`),
+            `Billing: plan=${billingGate.plan}, master_admin_free=${billingGate.masterAdminFree ? 'true' : 'false'}, vigcoin_required=${billingQuote.vigcoinRequired.toFixed(3)}, vigcoin_rate_usd=${billingQuote.vigcoinRateUsd.toFixed(4)}, total_usd=${billingQuote.finalUsd.toFixed(4)}`,
+            'Required flow: Detective repro -> 6-role parallel attack -> Architect synthesis -> test loop until pass.',
+        ].join('\n');
+        await this.planAndExecute(enrichedRequest, options, {
+            workspace,
+            originalRequest: request,
+            scan,
+            quote,
+        });
+    }
+    scanProject(workspace) {
+        const files = [];
+        const stack = [workspace];
+        const ignored = new Set(['.git', 'node_modules', 'dist', 'build', 'coverage', '.next', '__pycache__', '.venv']);
+        const exts = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.java']);
+        while (stack.length > 0 && files.length < 4000) {
+            const dir = stack.pop();
+            if (!dir)
+                continue;
+            let entries = [];
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const e of entries) {
+                if (ignored.has(e.name))
+                    continue;
+                const full = path.join(dir, e.name);
+                if (e.isDirectory()) {
+                    stack.push(full);
+                }
+                else if (e.isFile() && exts.has(path.extname(e.name).toLowerCase())) {
+                    files.push(full);
+                }
+            }
+        }
+        let lines = 0;
+        let importEdges = 0;
+        const topFiles = [];
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                const fileLines = content.split('\n').length;
+                const imports = (content.match(/^\s*(import\s+.+from\s+['"].+['"]|from\s+.+\s+import\s+.+|require\(.+\))/gm) || []).length;
+                lines += fileLines;
+                importEdges += imports;
+                topFiles.push({ file: path.relative(workspace, file).replace(/\\/g, '/'), lines: fileLines, imports });
+            }
+            catch {
+                continue;
+            }
+        }
+        topFiles.sort((a, b) => (b.lines + b.imports * 25) - (a.lines + a.imports * 25));
+        return { files: files.length, lines, importEdges, topFiles: topFiles.slice(0, 8) };
+    }
+    resolveModelProfiles(modelsArg) {
+        const catalog = [
+            { id: 'openrouter:openai/gpt-5.5', requestedModel: 'gpt-5.5', provider: 'openrouter', estInputPer1M: 5.0, estOutputPer1M: 30.0, capability: { reasoning: 10, coding: 10, security: 9, speed: 6, synthesis: 10 } },
+            { id: 'openrouter:anthropic/claude-opus-4.7', requestedModel: 'opus-4.7', provider: 'openrouter', estInputPer1M: 5.0, estOutputPer1M: 25.0, capability: { reasoning: 10, coding: 9, security: 10, speed: 6, synthesis: 10 } },
+            { id: 'openrouter:openai/o3', requestedModel: 'o3', provider: 'openrouter', estInputPer1M: 2.0, estOutputPer1M: 8.0, capability: { reasoning: 10, coding: 9, security: 9, speed: 6, synthesis: 9 } },
+            { id: 'openrouter:google/gemini-2.5-pro', requestedModel: 'gemini-2.5-pro', provider: 'openrouter', estInputPer1M: 1.25, estOutputPer1M: 10.0, capability: { reasoning: 9, coding: 9, security: 8, speed: 8, synthesis: 9 } },
+            { id: 'openrouter:deepseek/deepseek-v4-pro', requestedModel: 'deepseek-v4-pro', provider: 'openrouter', estInputPer1M: 0.435, estOutputPer1M: 0.87, capability: { reasoning: 8, coding: 9, security: 8, speed: 10, synthesis: 8 } },
+            { id: 'openrouter:moonshotai/kimi-k2.5', requestedModel: 'kimi-k2.5', provider: 'openrouter', estInputPer1M: 0.44, estOutputPer1M: 2.0, capability: { reasoning: 9, coding: 9, security: 8, speed: 8, synthesis: 9 } },
+            { id: 'openrouter:deepseek/deepseek-r1', requestedModel: 'cloud-reason', provider: 'openrouter', estInputPer1M: 0.7, estOutputPer1M: 2.5, capability: { reasoning: 9, coding: 8, security: 8, speed: 7, synthesis: 8 } },
+            { id: 'openrouter:deepseek/deepseek-chat', requestedModel: 'cloud-pro', provider: 'openrouter', estInputPer1M: 0.32, estOutputPer1M: 0.89, capability: { reasoning: 7, coding: 8, security: 7, speed: 10, synthesis: 7 } },
+        ];
+        if (!modelsArg || !modelsArg.trim())
+            return catalog;
+        const allow = new Set(modelsArg.split(',').map((m) => m.trim()).filter(Boolean));
+        const filtered = catalog.filter((m) => (allow.has(m.id)
+            || allow.has(m.id.replace('openrouter:', ''))
+            || allow.has(m.requestedModel)));
+        return filtered.length > 0 ? filtered : catalog;
+    }
+    buildRoleQuote(scan, models) {
+        const roleWeights = {
+            detective: { reasoning: 10, coding: 8, security: 6, speed: 3, synthesis: 7 },
+            logic: { reasoning: 8, coding: 10, security: 3, speed: 6, synthesis: 6 },
+            security: { reasoning: 7, coding: 7, security: 10, speed: 5, synthesis: 6 },
+            performance: { reasoning: 9, coding: 9, security: 7, speed: 5, synthesis: 7 },
+            edge_case: { reasoning: 8, coding: 7, security: 7, speed: 7, synthesis: 5 },
+            integration: { reasoning: 8, coding: 8, security: 6, speed: 5, synthesis: 8 },
+            reviewer: { reasoning: 9, coding: 7, security: 7, speed: 6, synthesis: 8 },
+            architect: { reasoning: 10, coding: 9, security: 8, speed: 4, synthesis: 10 },
+        };
+        const complexity = Math.max(1, Math.ceil((scan.lines / 4000) + (scan.importEdges / 200)));
+        return Object.keys(roleWeights).map((role) => {
+            const w = roleWeights[role];
+            const preferredByRole = {
+                detective: 'gpt-5.5',
+                logic: 'o3',
+                security: 'opus-4.7',
+                performance: 'deepseek-v4-pro',
+                edge_case: 'gemini-2.5-pro',
+                integration: 'kimi-k2.5',
+                reviewer: 'opus-4.7',
+                architect: 'gpt-5.5',
+            };
+            let best = models.find((m) => m.requestedModel === preferredByRole[role]) || models[0];
+            if (!best)
+                best = models[0];
+            // Fallback scoring when preferred model is filtered out by --models.
+            if (!models.some((m) => m.requestedModel === preferredByRole[role])) {
+                let bestScore = -1;
+                for (const m of models) {
+                    const score = m.capability.reasoning * w.reasoning + m.capability.coding * w.coding + m.capability.security * w.security + m.capability.speed * w.speed + m.capability.synthesis * w.synthesis;
+                    const costPenalty = (m.estInputPer1M + m.estOutputPer1M) * 0.1;
+                    const finalScore = score - costPenalty;
+                    if (finalScore > bestScore) {
+                        best = m;
+                        bestScore = finalScore;
+                    }
+                }
+            }
+            const estInputTokens = 1200 * complexity;
+            const estOutputTokens = 1800 * complexity;
+            const estCostUsd = (estInputTokens / 1_000_000) * best.estInputPer1M + (estOutputTokens / 1_000_000) * best.estOutputPer1M;
+            return { role, model: best.id, requestedModel: best.requestedModel, estInputTokens, estOutputTokens, estCostUsd };
+        });
+    }
+    buildGodmodeExplicitSteps(execution) {
+        const { originalRequest, workspace, scan, quote } = execution;
+        const quoteByRole = new Map(quote.map((row) => [row.role, row]));
+        const topFiles = scan.topFiles.slice(0, 5).map((file) => `${file.file} (${file.lines} lines, ${file.imports} imports)`);
+        const roleSequence = [
+            { role: 'detective', dependsOn: [] },
+            { role: 'logic', dependsOn: ['detective'] },
+            { role: 'security', dependsOn: ['detective'] },
+            { role: 'performance', dependsOn: ['detective'] },
+            { role: 'edge_case', dependsOn: ['detective'] },
+            { role: 'integration', dependsOn: ['detective'] },
+            { role: 'reviewer', dependsOn: ['detective'] },
+            { role: 'architect', dependsOn: ['logic', 'security', 'performance', 'edge_case', 'integration', 'reviewer'] },
+        ];
+        const roleIterationBudget = {
+            detective: 4,
+            logic: 5,
+            security: 5,
+            performance: 4,
+            edge_case: 4,
+            integration: 5,
+            reviewer: 5,
+            architect: 5,
+        };
+        const steps = roleSequence.map(({ role, dependsOn }) => {
+            const row = quoteByRole.get(role);
+            const requestedModel = row?.requestedModel || 'cloud-pro';
+            const model = row?.model || 'openrouter:deepseek/deepseek-chat';
+            const roleObjective = [
+                `[GODMODE:${role.toUpperCase()}]`,
+                originalRequest,
+                `Workspace: ${workspace}`,
+                `Execution contract: force requested_model=${requestedModel} via ${model}; do not substitute a local-only model.`,
+                `Project scan: files=${scan.files}, lines=${scan.lines}, import_edges=${scan.importEdges}`,
+                topFiles.length > 0 ? `Key files: ${topFiles.join('; ')}` : 'Key files: unavailable',
+                `Execution budget: at most ${roleIterationBudget[role] || 3} reasoning iterations; prioritize a one-pass final answer and avoid redundant full-repo rescans.`,
+            ].join('\n');
+            return {
+                step_id: role,
+                worker_name: 'v3_agent_worker',
+                objective: roleObjective,
+                depends_on: dependsOn,
+                priority: role === 'architect' ? 2 : 3,
+                retry_policy: {
+                    max_attempts: 1,
+                    strategy: 'repair',
+                    requires_validation_failure: false,
+                },
+                payload: {
+                    role,
+                    requested_model: requestedModel,
+                    quoted_model: model,
+                    workspace,
+                    top_files: topFiles,
+                    max_iterations: roleIterationBudget[role] || 4,
+                    compact_context: true,
+                    max_dependency_chars: role === 'architect' ? 18000 : 12000,
+                    max_artifacts: role === 'architect' ? 24 : 16,
+                    max_context_chars: role === 'architect' ? 240000 : 180000,
+                    max_output_tokens: role === 'detective' ? 3600 : role === 'architect' ? 3400 : role === 'reviewer' ? 3000 : 2400,
+                    request_timeout_seconds: role === 'detective' || role === 'architect' ? 1200 : 720,
+                },
+            };
+        });
+        steps.push({
+            step_id: 'testing',
+            worker_name: 'testing_worker',
+            objective: [
+                '[GODMODE:TESTING]',
+                originalRequest,
+                `Workspace: ${workspace}`,
+                'Validate the architect output, run the narrowest relevant checks, and report concrete failures if any remain.',
+            ].join('\n'),
+            depends_on: ['architect'],
+            priority: 2,
+            retry_policy: {
+                max_attempts: 1,
+                strategy: 'repair',
+                requires_validation_failure: false,
             },
-            constraints: {},
+            payload: {
+                workspace,
+                validation_min_score: 80,
+            },
+        });
+        return steps;
+    }
+    buildBillingQuote(quote) {
+        const baseUsd = quote.reduce((sum, r) => sum + r.estCostUsd, 0);
+        const marginPctRaw = Number.parseFloat(String(process.env.VIGTHORIA_GODMODE_MARGIN_PCT || '10'));
+        const marginPct = Number.isFinite(marginPctRaw) ? Math.max(0, marginPctRaw) : 10;
+        const finalUsd = baseUsd * (1 + (marginPct / 100));
+        const vigcoinRateRaw = Number.parseFloat(String(process.env.VIGTHORIA_VIGCOIN_USD_RATE || '1'));
+        const vigcoinRateUsd = Number.isFinite(vigcoinRateRaw) && vigcoinRateRaw > 0 ? vigcoinRateRaw : 1;
+        const vigcoinRequired = finalUsd / vigcoinRateUsd;
+        return {
+            baseUsd,
+            marginPct,
+            finalUsd,
+            vigcoinRateUsd,
+            vigcoinRequired,
         };
-        for (const baseUrl of HYPERLOOP_URLS) {
+    }
+    async evaluateBillingGate(billingQuote) {
+        const forcedPlan = String(process.env.VIGTHORIA_GODMODE_FORCE_PLAN || '').trim().toLowerCase();
+        // On-server invocations using a service key run as trusted infrastructure.
+        // No user wallet check is needed — cost is tracked at the service level.
+        const hasServiceKey = !!(process.env.HYPERLOOP_SERVICE_KEY || process.env.V3_SERVICE_KEY);
+        if (hasServiceKey) {
+            return {
+                plan: forcedPlan || this.config.getNormalizedPlan() || 'service',
+                masterAdminFree: true,
+                canProceed: true,
+                wallet: {
+                    available: true,
+                    vigcoinBalance: null,
+                    source: 'service_key_access',
+                    purchaseUrl: null,
+                },
+            };
+        }
+        const entitlement = await this.fetchGodmodeEntitlement();
+        const normalizedPlan = forcedPlan || entitlement.plan || this.config.getNormalizedPlan() || 'free';
+        const masterAdminFree = this.isMasterAdminFree(normalizedPlan, entitlement.masterAccess, entitlement.isMasterAdmin);
+        if (masterAdminFree) {
+            return {
+                plan: normalizedPlan,
+                masterAdminFree,
+                canProceed: true,
+                wallet: {
+                    available: true,
+                    vigcoinBalance: null,
+                    source: 'master_admin_access',
+                    purchaseUrl: null,
+                },
+            };
+        }
+        const wallet = await this.fetchWalletState();
+        if (!wallet.available || wallet.vigcoinBalance === null) {
+            return {
+                plan: normalizedPlan,
+                masterAdminFree,
+                canProceed: false,
+                wallet,
+            };
+        }
+        return {
+            plan: normalizedPlan,
+            masterAdminFree,
+            canProceed: wallet.vigcoinBalance >= billingQuote.vigcoinRequired,
+            wallet,
+        };
+    }
+    parseBooleanCandidate(value) {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'number') {
+            if (value === 1)
+                return true;
+            if (value === 0)
+                return false;
+            return null;
+        }
+        if (typeof value === 'string') {
+            const v = value.trim().toLowerCase();
+            if (['1', 'true', 'yes', 'enabled', 'on'].includes(v))
+                return true;
+            if (['0', 'false', 'no', 'disabled', 'off'].includes(v))
+                return false;
+        }
+        return null;
+    }
+    async fetchGodmodeEntitlement() {
+        if (process.env.VIGTHORIA_GODMODE_FORCE_MASTER_ACCESS === '1') {
+            return { plan: this.config.getNormalizedPlan() || 'free', masterAccess: true, isMasterAdmin: true };
+        }
+        const baseUrl = this.getBillingBaseUrl();
+        const headers = this.getHeaders();
+        const endpoints = ['/api/user/subscription', '/api/user/info', '/api/user/profile'];
+        for (const endpoint of endpoints) {
             try {
-                const response = await fetch(`${baseUrl}/legion/plan/execute`, {
-                    method: 'POST',
-                    headers: this.getHeaders(),
-                    body: JSON.stringify(body),
-                    signal: AbortSignal.timeout(300000),
+                const response = await fetch(`${baseUrl}${endpoint}`, {
+                    method: 'GET',
+                    signal: AbortSignal.timeout(12000),
+                    headers,
                 });
-                if (!response.ok) {
-                    const errorText = await response.text().catch(() => '');
-                    throw new Error(`Legion API ${response.status}: ${(0, api_js_1.describeUpstreamStatus)(response.status)}`);
-                }
-                const result = await response.json();
-                spinner.stop();
-                console.log();
-                console.log(chalk_1.default.bold.white(`  ${logger_js_1.CH.hLine.repeat(3)} Legion Execution Report ${logger_js_1.CH.hLine.repeat(34)}`));
-                console.log();
-                if (result.status === 'success' || result.ok) {
-                    console.log(chalk_1.default.green(`  ${logger_js_1.CH.success} Legion completed successfully`));
-                }
-                else if (result.status === 'partial') {
-                    console.log(chalk_1.default.yellow(`  ${logger_js_1.CH.warn} Legion completed partially`));
-                }
-                else {
-                    console.log(chalk_1.default.red(`  ${logger_js_1.CH.error} Legion execution failed`));
-                }
-                // Show execution graph results
-                if (result.graph_results || result.results) {
-                    const results = result.graph_results || result.results || [];
-                    const steps = Array.isArray(results) ? results : (typeof results === 'object' ? Object.values(results) : []);
-                    if (steps.length > 0) {
-                        console.log();
-                        console.log(chalk_1.default.white('  Steps:'));
-                        for (const step of steps) {
-                            const stepObj = step;
-                            const icon = stepObj.status === 'completed' || stepObj.success
-                                ? chalk_1.default.green(logger_js_1.CH.success)
-                                : chalk_1.default.red(logger_js_1.CH.error);
-                            const name = stepObj.step_id || stepObj.worker || stepObj.name || 'step';
-                            const summary = stepObj.summary || stepObj.result || '';
-                            console.log(`    ${icon} ${chalk_1.default.white(String(name))}${summary ? chalk_1.default.gray(` — ${String(summary).slice(0, 100)}`) : ''}`);
-                        }
+                if (!response.ok)
+                    continue;
+                const payload = await response.json();
+                const data = (payload && typeof payload === 'object') ? payload : {};
+                const plan = String(data.subscription?.plan
+                    || data.subscription_plan
+                    || data.plan
+                    || data.user?.subscription_plan
+                    || data.user?.subscription?.plan
+                    || '').trim().toLowerCase() || null;
+                const accessCandidates = [
+                    data.godmode_master_access,
+                    data.godmodeMasterAccess,
+                    data.subscription?.godmode_master_access,
+                    data.subscription?.godmodeMasterAccess,
+                    data.user?.godmode_master_access,
+                    data.user?.godmodeMasterAccess,
+                ];
+                const masterRoleCandidates = [
+                    data.user?.isMasterAdmin,
+                    data.user?.is_master_admin,
+                    data.subscription?.isMasterAdmin,
+                    data.subscription?.is_master_admin,
+                    data.isMasterAdmin,
+                    data.is_master_admin,
+                    data.user?.admin_role === 'master_admin',
+                    data.admin_role === 'master_admin',
+                ];
+                const roleHit = masterRoleCandidates
+                    .map((c) => this.parseBooleanCandidate(c))
+                    .find((v) => v !== null) ?? false;
+                for (const c of accessCandidates) {
+                    const parsed = this.parseBooleanCandidate(c);
+                    if (parsed !== null) {
+                        return { plan, masterAccess: parsed, isMasterAdmin: Boolean(roleHit) };
                     }
                 }
-                // Show timing and artifacts
-                if (result.elapsed_seconds || result.elapsed) {
-                    console.log();
-                    console.log(chalk_1.default.gray(`  Time: ${(result.elapsed_seconds || result.elapsed || 0).toFixed(1)}s`));
+                if (plan) {
+                    return { plan, masterAccess: false, isMasterAdmin: Boolean(roleHit) };
+                }
+            }
+            catch (err) {
+                this.logger.warn(this.formatLegionError(`Godmode entitlement request ${endpoint}`, err));
+                continue;
+            }
+        }
+        return {
+            plan: this.config.getNormalizedPlan() || null,
+            masterAccess: false,
+            isMasterAdmin: false,
+        };
+    }
+    isMasterAdminFree(plan, masterAccess, isMasterAdmin) {
+        if (!masterAccess) {
+            return false;
+        }
+        if (isMasterAdmin) {
+            return true;
+        }
+        return plan === 'master_admin';
+    }
+    getBillingBaseUrl() {
+        const configured = String(this.config.get('apiUrl') || '').trim().replace(/\/$/, '');
+        if (configured) {
+            return configured;
+        }
+        return 'https://coder.vigthoria.io';
+    }
+    parseNumericCandidate(value) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const parsed = Number.parseFloat(value.trim());
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+        return null;
+    }
+    extractVigcoinBalance(data) {
+        const candidates = [
+            data.vigcoinBalance,
+            data.vigcoin_balance,
+            data.balance,
+            data.credits,
+            data.credit_balance,
+            data.wallet?.vigcoinBalance,
+            data.wallet?.vigcoin_balance,
+            data.wallet?.balance,
+            data.wallet?.credits,
+            data.subscription?.vigcoinBalance,
+            data.subscription?.vigcoin_balance,
+            data.subscription?.credits,
+            data.user?.vigcoinBalance,
+            data.user?.vigcoin_balance,
+            data.user?.credits,
+            data.data?.vigcoinBalance,
+            data.data?.vigcoin_balance,
+            data.data?.balance,
+            data.data?.credits,
+        ];
+        for (const candidate of candidates) {
+            const parsed = this.parseNumericCandidate(candidate);
+            if (parsed !== null) {
+                return parsed;
+            }
+        }
+        return null;
+    }
+    getPurchaseUrlFromPayload(baseUrl, data) {
+        const raw = data.purchaseUrl || data.purchase_url || data.checkoutUrl || data.checkout_url || data.url || data.data?.checkoutUrl || data.data?.url;
+        if (typeof raw === 'string' && raw.trim()) {
+            if (/^https?:\/\//i.test(raw.trim())) {
+                return raw.trim();
+            }
+            return `${baseUrl}${raw.startsWith('/') ? '' : '/'}${raw.trim()}`;
+        }
+        return `${baseUrl}/billing`;
+    }
+    async fetchWalletState() {
+        const baseUrl = this.getBillingBaseUrl();
+        const headers = this.getHeaders();
+        const forcedLow = process.env.VIGTHORIA_GODMODE_FORCE_LOW_CREDIT === '1';
+        const forcedBalanceRaw = process.env.VIGTHORIA_GODMODE_FORCE_BALANCE;
+        if (forcedLow) {
+            return {
+                available: true,
+                vigcoinBalance: 0,
+                source: 'forced_low_credit',
+                purchaseUrl: `${baseUrl}/music/store#vigcoins`,
+            };
+        }
+        if (forcedBalanceRaw) {
+            const forced = this.parseNumericCandidate(forcedBalanceRaw);
+            if (forced !== null) {
+                return {
+                    available: true,
+                    vigcoinBalance: forced,
+                    source: 'forced_balance',
+                    purchaseUrl: `${baseUrl}/music/store#vigcoins`,
+                };
+            }
+        }
+        const endpoints = [
+            '/api/viagen6/vigcoin/balance',
+            '/api/user/subscription',
+            '/api/user/info',
+            '/api/user/profile',
+            '/api/wallet/balance',
+            '/api/billing/wallet',
+            '/api/billing/credits',
+        ];
+        for (const endpoint of endpoints) {
+            try {
+                const response = await fetch(`${baseUrl}${endpoint}`, {
+                    method: 'GET',
+                    signal: AbortSignal.timeout(12000),
+                    headers,
+                });
+                if (!response.ok) {
+                    continue;
                 }
-                if (result.content) {
-                    console.log();
-                    console.log(chalk_1.default.white(String(result.content).slice(0, 500)));
+                const payload = await this.readJsonResponse(response, `wallet balance request ${endpoint}`);
+                const payloadObj = (payload && typeof payload === 'object') ? payload : {};
+                const balance = this.extractVigcoinBalance(payloadObj);
+                if (balance === null) {
+                    continue;
                 }
-                console.log();
-                return;
+                return {
+                    available: true,
+                    vigcoinBalance: balance,
+                    source: endpoint,
+                    purchaseUrl: this.getPurchaseUrlFromPayload(baseUrl, payloadObj) || `${baseUrl}/music/store#vigcoins`,
+                };
+            }
+            catch (err) {
+                this.logger.warn(this.formatLegionError(`wallet balance request ${endpoint}`, err));
+                continue;
             }
-            catch (error) {
-                if (error?.name === 'AbortError') {
-                    spinner.stop();
-                    this.logger.error('Legion request timed out');
-                    return;
+        }
+        return {
+            available: false,
+            vigcoinBalance: null,
+            source: null,
+            purchaseUrl: `${baseUrl}/music/store#vigcoins`,
+            error: 'Wallet endpoint unavailable from current gateway session',
+        };
+    }
+    async attemptDirectCharge(vigcoinNeeded) {
+        const baseUrl = this.getBillingBaseUrl();
+        const headers = this.getHeaders();
+        const amount = Math.max(1, Math.ceil(vigcoinNeeded));
+        const chargePayloads = [
+            { endpoint: '/api/viagen6/vigcoin/charge', body: { amount, reason: 'godmode_legion' } },
+            { endpoint: '/api/wallet/charge', body: { amount, currency: 'VIGCOIN', reason: 'godmode_legion' } },
+            { endpoint: '/api/billing/topup', body: { vigcoin: amount, reason: 'godmode_legion' } },
+        ];
+        for (const attempt of chargePayloads) {
+            try {
+                const response = await fetch(`${baseUrl}${attempt.endpoint}`, {
+                    method: 'POST',
+                    signal: AbortSignal.timeout(15000),
+                    headers,
+                    body: JSON.stringify(attempt.body),
+                });
+                const payload = await response.json().catch((err) => {
+                    this.logger.warn(this.formatLegionError(`direct VigCoin charge response ${attempt.endpoint}`, err));
+                    return {};
+                });
+                const payloadObj = (payload && typeof payload === 'object') ? payload : {};
+                const checkoutUrl = this.getPurchaseUrlFromPayload(baseUrl, payloadObj) || `${baseUrl}/music/store#vigcoins`;
+                if (!response.ok) {
+                    continue;
+                }
+                const charged = payloadObj.charged === true || payloadObj.success === true || payloadObj.status === 'charged';
+                if (charged) {
+                    return { ok: true, checkoutUrl: checkoutUrl || undefined, note: `Charge accepted by ${attempt.endpoint}` };
                 }
-                // Try next URL
+                return {
+                    ok: false,
+                    checkoutUrl: checkoutUrl || undefined,
+                    note: payloadObj.error || payloadObj.message || `Checkout required via ${attempt.endpoint}`,
+                };
+            }
+            catch (err) {
+                this.logger.warn(this.formatLegionError(`direct VigCoin charge request ${attempt.endpoint}`, err));
                 continue;
             }
         }
+        return {
+            ok: false,
+            checkoutUrl: `${baseUrl}/music/store#vigcoins`,
+            note: 'No direct charge endpoint accepted this request',
+        };
+    }
+    async collectExecutionCharge(billingQuote, gate) {
+        if (gate.masterAdminFree) {
+            return true;
+        }
+        const spinner = (0, logger_js_1.createSpinner)('Charging VigCoin wallet for Godmode execution...').start();
+        const result = await this.attemptDirectCharge(billingQuote.vigcoinRequired);
         spinner.stop();
-        this.logger.error('Could not reach Hyper Loop Legion API. Is vigthoria-hyper-loop running?');
+        if (!result.ok) {
+            console.log(chalk_1.default.red(result.note || 'Wallet charge failed.'));
+            console.log(chalk_1.default.yellow(`Complete purchase first: ${result.checkoutUrl || `${this.getBillingBaseUrl()}/music/store#vigcoins`}`));
+            return false;
+        }
+        console.log(chalk_1.default.green('Wallet charged for Godmode execution.'));
+        return true;
+    }
+    async resolveBillingInsufficientFunds(billingQuote, gate, options) {
+        this.printBillingGateSummary(billingQuote, gate);
+        if (!gate.wallet.available) {
+            console.log(chalk_1.default.red('Unable to verify wallet balance from server. Execution is blocked.'));
+            if (gate.wallet.purchaseUrl) {
+                console.log(chalk_1.default.gray(`Open billing portal: ${gate.wallet.purchaseUrl}`));
+            }
+            return false;
+        }
+        if (options.autoCharge) {
+            const spinner = (0, logger_js_1.createSpinner)('Attempting direct wallet charge...').start();
+            const result = await this.attemptDirectCharge(billingQuote.vigcoinRequired - (gate.wallet.vigcoinBalance || 0));
+            spinner.stop();
+            if (result.ok) {
+                console.log(chalk_1.default.green('Direct charge succeeded. Re-checking wallet balance...'));
+                return true;
+            }
+            console.log(chalk_1.default.yellow(result.note || 'Direct charge did not complete.'));
+            console.log(chalk_1.default.yellow(`Complete purchase first: ${result.checkoutUrl || gate.wallet.purchaseUrl || `${this.getBillingBaseUrl()}/billing`}`));
+            return false;
+        }
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.log(chalk_1.default.yellow('Low balance detected in non-interactive mode. Re-run with --auto-charge or top up first.'));
+            if (gate.wallet.purchaseUrl) {
+                console.log(chalk_1.default.gray(`Billing portal: ${gate.wallet.purchaseUrl}`));
+            }
+            return false;
+        }
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question('VigCoin low. Choose action: [c]harge now, [p]urchase first, [n] cancel: ')).trim().toLowerCase();
+            if (answer === 'c' || answer === 'charge') {
+                const spinner = (0, logger_js_1.createSpinner)('Attempting direct wallet charge...').start();
+                const result = await this.attemptDirectCharge(billingQuote.vigcoinRequired - (gate.wallet.vigcoinBalance || 0));
+                spinner.stop();
+                if (result.ok) {
+                    console.log(chalk_1.default.green('Direct charge succeeded. Re-checking wallet balance...'));
+                    return true;
+                }
+                console.log(chalk_1.default.yellow(result.note || 'Direct charge did not complete.'));
+                console.log(chalk_1.default.yellow(`Complete purchase first: ${result.checkoutUrl || gate.wallet.purchaseUrl || `${this.getBillingBaseUrl()}/billing`}`));
+                return false;
+            }
+            if (answer === 'p' || answer === 'purchase') {
+                console.log(chalk_1.default.yellow(`Purchase VigCoin first: ${gate.wallet.purchaseUrl || `${this.getBillingBaseUrl()}/billing`}`));
+                return false;
+            }
+            return false;
+        }
+        finally {
+            rl.close();
+        }
+    }
+    printBillingGateSummary(billingQuote, gate) {
+        console.log(chalk_1.default.white('  Billing gate:'));
+        console.log(chalk_1.default.gray(`    Plan: ${gate.plan}`));
+        if (gate.masterAdminFree) {
+            console.log(chalk_1.default.green('    Free tier override applied (Master Admin).'));
+            return;
+        }
+        console.log(chalk_1.default.gray(`    Estimated total (USD): $${billingQuote.finalUsd.toFixed(4)}`));
+        console.log(chalk_1.default.gray(`    VigCoin rate: 1 VIG = $${billingQuote.vigcoinRateUsd.toFixed(4)}`));
+        console.log(chalk_1.default.gray(`    VigCoin required: ${billingQuote.vigcoinRequired.toFixed(3)}`));
+        if (gate.wallet.vigcoinBalance !== null) {
+            const color = gate.wallet.vigcoinBalance >= billingQuote.vigcoinRequired ? chalk_1.default.green : chalk_1.default.red;
+            console.log(chalk_1.default.gray('    Wallet balance: ') + color(gate.wallet.vigcoinBalance.toFixed(3)) + (gate.wallet.source ? chalk_1.default.gray(` (source: ${gate.wallet.source})`) : ''));
+        }
+        else {
+            console.log(chalk_1.default.red(`    Wallet balance: unavailable${gate.wallet.error ? ` (${gate.wallet.error})` : ''}`));
+        }
+        if (gate.wallet.purchaseUrl) {
+            console.log(chalk_1.default.gray(`    Purchase URL: ${gate.wallet.purchaseUrl}`));
+        }
+    }
+    printGodmodeQuote(workspace, scan, quote, billingQuote, gate) {
+        const totalCost = billingQuote.finalUsd;
+        console.log();
+        console.log(chalk_1.default.bold.white(`  ${logger_js_1.CH.hLine.repeat(3)} Legion Godmode Calculator ${logger_js_1.CH.hLine.repeat(31)}`));
+        console.log();
+        console.log(chalk_1.default.gray('  Workspace: ') + chalk_1.default.white(workspace));
+        console.log(chalk_1.default.gray('  Files scanned: ') + chalk_1.default.white(String(scan.files)));
+        console.log(chalk_1.default.gray('  Lines scanned: ') + chalk_1.default.white(String(scan.lines)));
+        console.log(chalk_1.default.gray('  Dependency edges: ') + chalk_1.default.white(String(scan.importEdges)));
+        if (scan.topFiles.length > 0) {
+            console.log();
+            console.log(chalk_1.default.white('  Top context files:'));
+            for (const f of scan.topFiles) {
+                console.log(chalk_1.default.gray(`    ${logger_js_1.CH.bullet} ${f.file} (${f.lines} lines, ${f.imports} imports)`));
+            }
+        }
+        console.log();
+        console.log(chalk_1.default.white('  Role assignment and estimated cost:'));
+        for (const row of quote) {
+            console.log(chalk_1.default.gray(`    ${logger_js_1.CH.bullet} ${row.role.padEnd(11)} ${row.model}  $${row.estCostUsd.toFixed(4)}`));
+        }
+        console.log();
+        console.log(chalk_1.default.yellow(`  Estimated total: $${totalCost.toFixed(4)}`));
+        console.log(chalk_1.default.gray('  Flow: Estimate -> Isolation -> Parallel Attack -> Synthesis'));
+        console.log();
+        this.printBillingGateSummary(billingQuote, gate);
+        console.log();
+    }
+    async confirmExecution() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.log(chalk_1.default.yellow('Non-interactive terminal detected. Re-run with --approve to continue execution.'));
+            return false;
+        }
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question('Proceed with Godmode execution? (y/N): ')).trim().toLowerCase();
+            return answer === 'y' || answer === 'yes';
+        }
+        finally {
+            rl.close();
+        }
+    }
+    /**
+     * SSE streaming URL for the Legion execution endpoint.
+     * Always hits Hyper Loop directly (port 8020) with the service key to avoid
+     * gateway JWT expiry killing long-running GodMode jobs.
+     */
+    getLegionStreamUrl() {
+        const envOverride = String(process.env.VIGTHORIA_HYPERLOOP_URL || '').trim().replace(/\/$/, '');
+        if (envOverride)
+            return `${envOverride}/legion/stream`;
+        return 'http://localhost:8020/api/hyperloop/legion/stream';
+    }
+    getLegionServiceKey() {
+        // Service key lets on-server CLI calls bypass gateway JWT validation
+        return String(process.env.HYPERLOOP_SERVICE_KEY ||
+            process.env.V3_SERVICE_KEY ||
+            '');
+    }
+    async planAndExecute(request, options, godmodeExecution) {
+        const explicitSteps = godmodeExecution ? this.buildGodmodeExplicitSteps(godmodeExecution) : undefined;
+        const workspace = godmodeExecution?.workspace || options.project || process.cwd();
+        const body = {
+            request,
+            context: { workspace },
+            constraints: {
+                active_only: true,
+                execution_timeout_seconds: options.timeoutSec,
+                preferred_workers: explicitSteps ? undefined : ['v3_agent_worker'],
+                explicit_steps: explicitSteps,
+            },
+        };
+        const streamUrl = this.getLegionStreamUrl();
+        const serviceKey = this.getLegionServiceKey();
+        const headers = { 'Content-Type': 'application/json' };
+        if (serviceKey) {
+            headers['X-Service-Key'] = serviceKey;
+        }
+        else {
+            // Fallback: pass user JWT (works if token is still valid)
+            const token = this.config.get('authToken');
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+                headers['Cookie'] = `vigthoria-auth-token=${token}`;
+            }
+        }
+        const spinner = (0, logger_js_1.createSpinner)('Connecting to Legion SSE stream...').start();
+        const startTime = Date.now();
+        let response;
+        try {
+            // No AbortSignal timeout — SSE keeps alive; server controls lifetime
+            response = await fetch(streamUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+            });
+        }
+        catch (connErr) {
+            spinner.stop();
+            this.logger.error(`Cannot connect to Hyper Loop at ${streamUrl}: ${connErr?.message || connErr}`);
+            return;
+        }
+        if (!response.ok) {
+            spinner.stop();
+            const errBody = await response.text().catch(() => '');
+            this.logger.error(`Legion stream ${response.status}: ${(0, api_js_1.describeUpstreamStatus)(response.status)} — ${errBody.slice(0, 200)}`);
+            return;
+        }
+        if (!response.body) {
+            spinner.stop();
+            this.logger.error('Legion stream returned no response body');
+            return;
+        }
+        // ── SSE consumer ─────────────────────────────────────────────
+        spinner.stop();
+        console.log();
+        console.log(chalk_1.default.bold.white(`  ${logger_js_1.CH.hLine.repeat(3)} Legion Execution Report ${logger_js_1.CH.hLine.repeat(34)}`));
+        console.log();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let finalResult = null;
+        let stepsTotal = 0;
+        let stepsDone = 0;
+        try {
+            const reader = response.body.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? ''; // keep incomplete last line
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith(':'))
+                        continue; // keep-alive or comment
+                    if (!trimmed.startsWith('data:'))
+                        continue;
+                    const jsonStr = trimmed.slice(5).trim();
+                    let evt;
+                    try {
+                        evt = JSON.parse(jsonStr);
+                    }
+                    catch {
+                        continue;
+                    }
+                    switch (evt.event) {
+                        case 'plan':
+                            stepsTotal = evt.steps_total || 0;
+                            console.log(chalk_1.default.gray(`  Planned workers: ${stepsTotal} steps queued`));
+                            console.log();
+                            break;
+                        case 'batch_start':
+                            console.log(chalk_1.default.gray(`  ▶ Running: ${evt.workers.join(', ')} (${evt.steps_done}/${evt.steps_total})`));
+                            break;
+                        case 'step_complete': {
+                            stepsDone = Number(evt.steps_done) || 0;
+                            const icon = evt.status === 'completed' ? chalk_1.default.green(logger_js_1.CH.success) : chalk_1.default.red(logger_js_1.CH.error);
+                            const summary = evt.summary ? chalk_1.default.gray(` — ${String(evt.summary).slice(0, 120)}`) : '';
+                            console.log(`    ${icon} ${chalk_1.default.white(String(evt.step_id))} ${chalk_1.default.gray('[' + evt.worker + ']')}${summary}`);
+                            break;
+                        }
+                        case 'complete':
+                            finalResult = evt.result || null;
+                            if (evt.status === 'completed') {
+                                console.log();
+                                console.log(chalk_1.default.green(`  ${logger_js_1.CH.success} Legion completed successfully`));
+                            }
+                            else if (evt.status === 'failed') {
+                                console.log();
+                                console.log(chalk_1.default.red(`  ${logger_js_1.CH.error} Legion execution failed`));
+                                if (evt.error)
+                                    console.log(chalk_1.default.red(`  Error: ${String(evt.error).slice(0, 300)}`));
+                            }
+                            break;
+                        case 'error':
+                            console.log(chalk_1.default.red(`  ${logger_js_1.CH.error} Stream error: ${String(evt.error).slice(0, 300)}`));
+                            break;
+                    }
+                }
+            }
+        }
+        catch (streamErr) {
+            this.logger.error(`Legion stream read error: ${streamErr?.message || streamErr}`);
+        }
+        const elapsedSec = ((Date.now() - startTime) / 1000).toFixed(1);
+        if (stepsTotal > 0 && stepsDone < stepsTotal) {
+            console.log(chalk_1.default.yellow(`  ${logger_js_1.CH.warn} Legion stream ended after ${stepsDone}/${stepsTotal} steps`));
+        }
+        console.log();
+        console.log(chalk_1.default.gray(`  Time: ${elapsedSec}s`));
+        // Show final output from architect/last step
+        if (finalResult) {
+            const lastStepResult = finalResult.final_output;
+            const summary = lastStepResult?.result?.summary || lastStepResult?.summary || '';
+            if (summary) {
+                console.log();
+                console.log(chalk_1.default.white('  Final output:'));
+                console.log(chalk_1.default.gray(`  ${String(summary).slice(0, 600)}`));
+            }
+        }
+        console.log();
+    }
+    formatLegionError(context, err) {
+        const message = err?.message || String(err || 'Unknown error');
+        const cause = err?.cause?.message ? ` (${err.cause.message})` : '';
+        return `${context} failed: ${message}${cause}`;
     }
     async showWorkers() {
         const spinner = (0, logger_js_1.createSpinner)('Fetching Legion worker catalog...').start();
-        for (const baseUrl of HYPERLOOP_URLS) {
+        let lastError = null;
+        for (const baseUrl of this.getHyperloopUrls()) {
             try {
                 const response = await fetch(`${baseUrl}/legion/workers`, {
                     signal: AbortSignal.timeout(10000),
                     headers: this.getHeaders(),
                 });
-                if (!response.ok)
+                if (!response.ok) {
+                    const errBody = await response.text().catch((err) => {
+                        this.logger.warn(this.formatLegionError(`worker catalog error body at ${baseUrl}`, err));
+                        return '';
+                    });
+                    lastError = `Legion worker catalog request at ${baseUrl} failed: ${response.status} ${(0, api_js_1.describeUpstreamStatus)(response.status)}${errBody ? ` — ${errBody.slice(0, 200)}` : ''}`;
                     continue;
-                const data = await response.json();
+                }
+                const data = await this.readJsonResponse(response, `worker catalog request at ${baseUrl}`);
                 spinner.stop();
                 console.log();
                 console.log(chalk_1.default.bold.white(`  ${logger_js_1.CH.hLine.repeat(3)} Legion Worker Catalog ${logger_js_1.CH.hLine.repeat(37)}`));
@@ -186,24 +1106,28 @@ class LegionCommand {
                 console.log();
                 return;
             }
-            catch {
+            catch (err) {
+                lastError = this.formatLegionError(`worker catalog request at ${baseUrl}`, err);
                 continue;
             }
         }
         spinner.stop();
-        this.logger.error('Could not reach Hyper Loop. Is vigthoria-hyper-loop running?');
+        this.logger.error(lastError || 'Could not reach Hyper Loop. Is vigthoria-hyper-loop running?');
     }
     async showStatus() {
         const spinner = (0, logger_js_1.createSpinner)('Checking Legion infrastructure...').start();
-        for (const baseUrl of HYPERLOOP_URLS) {
+        let lastError = null;
+        for (const baseUrl of this.getHyperloopUrls()) {
             try {
                 const response = await fetch(`${baseUrl}/status`, {
                     signal: AbortSignal.timeout(10000),
                     headers: this.getHeaders(),
                 });
-                if (!response.ok)
+                if (!response.ok) {
+                    lastError = `Legion status check at ${baseUrl} failed: ${response.status} ${(0, api_js_1.describeUpstreamStatus)(response.status)}`;
                     continue;
-                const data = await response.json();
+                }
+                const data = await this.readJsonResponse(response, `status check at ${baseUrl}`);
                 spinner.stop();
                 console.log();
                 console.log(chalk_1.default.bold.white(`  ${logger_js_1.CH.hLine.repeat(3)} Legion Infrastructure ${logger_js_1.CH.hLine.repeat(37)}`));
@@ -225,13 +1149,17 @@ class LegionCommand {
                 console.log();
                 return;
             }
-            catch {
+            catch (err) {
+                lastError = this.formatLegionError(`status check at ${baseUrl}`, err);
                 continue;
             }
         }
         spinner.stop();
         console.log();
         console.log(chalk_1.default.gray('  Hyper Loop: ') + chalk_1.default.red('offline'));
+        if (lastError) {
+            this.logger.error(lastError);
+        }
         console.log();
     }
 }