vigthoria-cli 1.13.20 → 1.13.22

package/dist/commands/fork.js

@@ -1,17 +1,16 @@
-import { isServerRuntime } from '../utils/api.js';
+import { hasLocalV3AgentCapability } from '../utils/runtime-capability.js';
 /**
  * fork.ts — Fork from an existing V3 agent run and stream the result.
  */
 import chalk from 'chalk';
 import { createRequire } from 'node:module';
 import { createSpinner, CH } from '../utils/logger.js';
+import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/command-contract.js';
 const require = createRequire(import.meta.url);
 export class ForkCommand {
     config;
-    logger;
-    constructor(config, logger) {
+    constructor(config, _logger) {
         this.config = config;
-        this.logger = logger;
     }
     getHeaders() {
         const headers = { 'Content-Type': 'application/json' };
@@ -29,7 +28,7 @@ export class ForkCommand {
     }
     getBaseUrl() {
         const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
-        const allowLocal = isServerRuntime() && process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
+        const allowLocal = hasLocalV3AgentCapability();
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
             (allowLocal ? 'http://127.0.0.1:8030' : null) ||
@@ -53,6 +52,13 @@ export class ForkCommand {
         const workspace = this.resolveWorkspaceRoot(project);
         const eventIndex = options.eventIndex || 0;
         const spinner = createSpinner(`Forking run ${runId}...`).start();
+        const streamController = new AbortController();
+        let interrupted = false;
+        const onInterrupt = () => {
+            interrupted = true;
+            streamController.abort();
+        };
+        process.once('SIGINT', onInterrupt);
         try {
             const baseUrl = this.getBaseUrl();
             const body = {
@@ -66,33 +72,57 @@ export class ForkCommand {
                 method: 'POST',
                 headers: this.getHeaders(),
                 body: JSON.stringify(body),
+                signal: streamController.signal,
             });
             if (!resp.ok) {
                 spinner.stop();
                 if (resp.status === 404) {
-                    this.logger.error(`Run ${runId} not found or has no event log.`);
+                    throw new CliCommandError(`Run ${runId} not found or has no event log.`, {
+                        code: 'RUN_NOT_FOUND', status: resp.status,
+                    });
                 }
                 else if (resp.status === 502 || resp.status === 503) {
-                    this.logger.error(`V3 run-history route is not available on ${baseUrl}. Backend may not expose /api/runs.`);
+                    throw new CliCommandError(`V3 run-history route is not available on ${baseUrl}. Backend may not expose /api/runs.`, {
+                        code: 'RUN_HISTORY_UNAVAILABLE', status: resp.status, category: 'network',
+                    });
                 }
                 else {
-                    this.logger.error(`Fork failed: ${resp.status} ${resp.statusText}`);
+                    throw new CliCommandError(`Fork failed: ${resp.status} ${resp.statusText}`, {
+                        code: 'RUN_FORK_FAILED', status: resp.status,
+                    });
                 }
-                return;
             }
             spinner.stop();
-            console.log(chalk.bold(`\n${CH.success} Forked from ${chalk.cyan(runId)} at event ${eventIndex}\n`));
+            if (!options.json)
+                console.log(chalk.bold(`\n${CH.success} Forked from ${chalk.cyan(runId)} at event ${eventIndex}\n`));
             if (!resp.body) {
-                this.logger.error('No response body');
-                return;
+                throw new CliCommandError('Fork response did not contain an event stream', { code: 'RUN_FORK_STREAM_MISSING' });
             }
             // Stream SSE events
             const reader = resp.body.getReader();
             const decoder = new TextDecoder();
             let buffer = '';
             let toolCallNum = 0;
-            while (true) {
-                const { done, value } = await reader.read();
+            let completed = false;
+            const events = [];
+            const configuredIdle = Number.parseInt(process.env.VIGTHORIA_FORK_IDLE_TIMEOUT_MS || '', 10);
+            const idleTimeoutMs = Number.isFinite(configuredIdle) && configuredIdle > 0 ? configuredIdle : 60_000;
+            stream: while (true) {
+                let timer;
+                const { done, value } = await Promise.race([
+                    reader.read(),
+                    new Promise((_resolve, reject) => {
+                        timer = setTimeout(() => {
+                            streamController.abort();
+                            reject(new CliCommandError(`Fork event stream was idle for ${idleTimeoutMs}ms.`, {
+                                code: 'RUN_FORK_IDLE_TIMEOUT', category: 'network',
+                            }));
+                        }, idleTimeoutMs);
+                    }),
+                ]).finally(() => {
+                    if (timer)
+                        clearTimeout(timer);
+                });
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });
@@ -103,14 +133,14 @@ export class ForkCommand {
                         continue;
                     const payload = line.slice(6).trim();
                     if (payload === '[DONE]') {
-                        console.log(chalk.bold(`\n${CH.success} Fork run complete\n`));
-                        return;
+                        completed = true;
+                        break stream;
                     }
                     try {
                         const evt = JSON.parse(payload);
                         const type = evt.type || 'unknown';
+                        events.push(evt);
                         if (options.json) {
-                            console.log(JSON.stringify(evt));
                             continue;
                         }
                         switch (type) {
@@ -144,21 +174,41 @@ export class ForkCommand {
                                 break;
                             }
                             case 'error':
-                                console.log(chalk.red(`  ❌ ERROR: `) + (evt.message || '').substring(0, 200));
-                                break;
+                                throw new CliCommandError(String(evt.message || 'Fork stream reported an error.'), {
+                                    code: 'RUN_FORK_STREAM_ERROR', details: evt,
+                                });
                             default:
                                 console.log(chalk.dim(`  ${type}: ${JSON.stringify(evt).substring(0, 80)}`));
                         }
                     }
-                    catch {
-                        // skip unparseable lines
+                    catch (error) {
+                        if (error instanceof CliCommandError)
+                            throw error;
+                        throw new CliCommandError('Fork event stream contained malformed JSON.', {
+                            code: 'RUN_FORK_STREAM_MALFORMED', details: { payload: payload.slice(0, 200) }, cause: error,
+                        });
                     }
                 }
             }
+            if (!completed) {
+                throw new CliCommandError('Fork event stream ended without a completion marker.', { code: 'RUN_FORK_STREAM_INCOMPLETE' });
+            }
+            if (options.json) {
+                console.log(formatSuccessJson('fork', { runId, eventIndex, events }, { stream: true, eventCount: events.length }));
+            }
+            else {
+                console.log(chalk.bold(`\n${CH.success} Fork run complete\n`));
+            }
         }
         catch (err) {
             spinner.stop();
-            this.logger.error(`Fork error: ${err.message}`);
+            if (interrupted) {
+                throw new CliCommandError('Fork cancelled by user.', { code: 'RUN_FORK_CANCELLED', category: 'cancelled', cause: err });
+            }
+            throw commandFailure(err, { code: 'RUN_FORK_FAILED' });
+        }
+        finally {
+            process.removeListener('SIGINT', onInterrupt);
         }
     }
 }

package/dist/commands/game.d.ts

@@ -18,7 +18,7 @@ export declare class GameCommand {
     }): Promise<void>;
     validate(o: CommonOptions & {
         json?: boolean;
-    }): Promise<boolean>;
+    }): Promise<true>;
     private project;
     private sources;
     private finish;

package/dist/commands/game.js

@@ -3,6 +3,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import inquirer from 'inquirer';
 import { runPostWriteValidation } from '../utils/post-write-validator.js';
+import { assertProcessNetworkAllowed } from '../utils/process-policy.js';
+import { safeChildProcessEnv } from '../utils/secret-policy.js';
+import { CliCommandError, formatSuccessJson } from '../utils/command-contract.js';
 const NAME = /^[a-zA-Z0-9][a-zA-Z0-9 _-]{0,63}$/;
 const manager = (root, requested) => {
     if (requested)
@@ -21,7 +24,11 @@ const manager = (root, requested) => {
         return 'bun';
     return 'npm';
 };
-const run = (pm, args, cwd) => new Promise((resolve, reject) => { const child = spawn(process.platform === 'win32' ? `${pm}.cmd` : pm, args, { cwd, stdio: 'inherit', windowsHide: true }); child.once('error', reject); child.once('exit', (code, signal) => code === 0 ? resolve() : reject(new Error(`${pm} exited with ${signal || code}`))); });
+const run = (pm, args, cwd, timeoutMs = 10 * 60_000) => new Promise((resolve, reject) => { const executable = process.platform === 'win32' ? `${pm}.cmd` : pm; assertProcessNetworkAllowed(executable, args); const child = spawn(executable, args, { cwd, stdio: 'inherit', windowsHide: true, env: safeChildProcessEnv() }); let interrupted = false; const onInterrupt = () => { interrupted = true; child.kill('SIGINT'); }; process.once('SIGINT', onInterrupt); const timer = timeoutMs > 0 ? setTimeout(() => { child.kill('SIGTERM'); reject(new CliCommandError(`${pm} command timed out after ${timeoutMs}ms`, { code: 'GAME_PROCESS_TIMEOUT' })); }, timeoutMs) : null; const finish = () => { if (timer)
+    clearTimeout(timer); process.removeListener('SIGINT', onInterrupt); }; child.once('error', error => { finish(); reject(error); }); child.once('exit', (code, signal) => { finish(); if (interrupted)
+    reject(new CliCommandError(`${pm} command cancelled by user`, { code: 'GAME_PROCESS_CANCELLED', category: 'cancelled' }));
+else
+    code === 0 ? resolve() : reject(new Error(`${pm} exited with ${signal || code}`)); }); });
 const html = `<!doctype html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>VGE Game</title></head><body><canvas id="game"></canvas><div id="hud"><strong>Vigthoria Gaming Engine</strong><span>Ready</span></div><script type="module" src="/src/main.ts"></script></body></html>\n`;
 const style = `*{box-sizing:border-box}html,body,#game{width:100%;height:100%;margin:0;overflow:hidden}body{background:#030510;color:#e8f7ff;font-family:Inter,system-ui,sans-serif}#game{display:block;touch-action:none}#hud{position:fixed;left:24px;top:24px;display:flex;gap:16px;padding:12px 16px;border:1px solid #00d4ff66;border-radius:12px;background:#070a18cc;backdrop-filter:blur(12px);box-shadow:0 0 32px #7c3aed33}#hud span{color:#5eead4}\n`;
 const main = `import { ArcRotateCamera, Color3, Color4, DirectionalLight, Engine, HemisphericLight, MeshBuilder, PBRMaterial, Scene, ShadowGenerator, Vector3 } from '@babylonjs/core';
@@ -65,7 +72,7 @@ export class GameCommand {
     }
     async run(o) { const root = path.resolve(o.project || process.cwd()); this.project(root); const args = ['run', 'dev', '--', '--host', '127.0.0.1']; if (o.port)
         args.push('--port', String(o.port)); if (o.open !== false)
-        args.push('--open'); await run(manager(root, o.packageManager), args, root); }
+        args.push('--open'); await run(manager(root, o.packageManager), args, root, 0); }
     async validate(o) {
         const root = path.resolve(o.project || process.cwd());
         const checks = [];
@@ -104,10 +111,14 @@ export class GameCommand {
         else if (/\.(html|[cm]?[jt]sx?)$/.test(e.name))
             files.push(f);
     } }; walk(root); return files.map(f => fs.readFileSync(f, 'utf8')).join('\n'); }
-    finish(checks, json = false) { const passed = checks.every(x => x.passed); if (json)
-        console.log(JSON.stringify({ passed, checks }, null, 2));
+    finish(checks, json = false) { const passed = checks.every(x => x.passed); if (!passed) {
+        if (!json)
+            for (const c of checks)
+                (c.passed ? this.logger.success.bind(this.logger) : this.logger.error.bind(this.logger))(`${c.check}${c.detail ? `: ${c.detail.trim().slice(0, 500)}` : ''}`);
+        throw new CliCommandError('Game validation failed', { code: 'GAME_VALIDATION_FAILED', details: { checks } });
+    } if (json)
+        console.log(formatSuccessJson('game validate', { passed, checks }));
     else
         for (const c of checks)
-            (c.passed ? this.logger.success.bind(this.logger) : this.logger.error.bind(this.logger))(`${c.check}${c.detail ? `: ${c.detail.trim().slice(0, 500)}` : ''}`); if (!passed)
-        process.exitCode = 1; return passed; }
+            this.logger.success(`${c.check}${c.detail ? `: ${c.detail.trim().slice(0, 500)}` : ''}`); return passed; }
 }

package/dist/commands/generate.js

@@ -6,8 +6,9 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { createSpinner, CH } from '../utils/logger.js';
-import { APIClient, CLIError, classifyError, formatCLIError } from '../utils/api.js';
+import { createAPIClient } from '../utils/api-client-factory.js';
 import { FileUtils } from '../utils/files.js';
+import { CliCommandError, commandFailure } from '../utils/command-contract.js';
 export class GenerateCommand {
     config;
     logger;
@@ -16,20 +17,18 @@ export class GenerateCommand {
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
-        this.api = new APIClient(config, logger);
+        this.api = createAPIClient(config, logger);
         this.fileUtils = new FileUtils(process.cwd(), config.get('project').ignorePatterns);
     }
     async run(description, options) {
         // Check auth
         if (!this.config.isAuthenticated()) {
-            this.logger.error('Not authenticated. Run: vigthoria login');
-            return;
+            throw new CliCommandError('Not authenticated. Run: vigthoria login', { code: 'AUTH_REQUIRED', category: 'authentication' });
         }
         // Server-side token validation — fail fast instead of waiting for 401
         const tokenCheck = await this.api.validateToken();
         if (!tokenCheck.valid) {
-            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
-            return;
+            throw new CliCommandError(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login', { code: 'AUTH_SESSION_INVALID', category: 'authentication' });
         }
         // Determine mode
         const proMode = options.pro === true;
@@ -106,8 +105,7 @@ export class GenerateCommand {
         }
         catch (error) {
             spinner.stop();
-            const cliErr = error instanceof CLIError ? error : classifyError(error);
-            this.logger.error(formatCLIError(cliErr));
+            throw commandFailure(error, { code: 'GENERATE_FAILED' });
         }
     }
     /**
@@ -167,7 +165,7 @@ export class GenerateCommand {
             this.logger.success(`Code saved to ${filePath}`);
         }
         else {
-            this.logger.error('Failed to save file');
+            throw new CliCommandError(`Failed to save file: ${filePath}`, { code: 'FILE_WRITE_FAILED' });
         }
     }
     async promptForAction(code, language) {

package/dist/commands/history.js

@@ -1,10 +1,11 @@
-import { isServerRuntime } from '../utils/api.js';
+import { hasLocalV3AgentCapability } from '../utils/runtime-capability.js';
 /**
  * history.ts — List recent V3 agent runs with summaries.
  */
 import chalk from 'chalk';
 import { createRequire } from 'node:module';
 import { createSpinner, CH } from '../utils/logger.js';
+import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/command-contract.js';
 const require = createRequire(import.meta.url);
 export class HistoryCommand {
     config;
@@ -29,7 +30,7 @@ export class HistoryCommand {
     }
     getBaseUrl() {
         const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
-        const allowLocal = isServerRuntime() && process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
+        const allowLocal = hasLocalV3AgentCapability();
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
             (allowLocal ? 'http://127.0.0.1:8030' : null) ||
@@ -68,17 +69,20 @@ export class HistoryCommand {
             if (!resp.ok) {
                 spinner.stop();
                 if (resp.status === 404 || resp.status === 502 || resp.status === 503) {
-                    this.logger.error(`V3 run-history route is not available on ${baseUrl}. Backend may not expose /api/runs.`);
+                    throw new CliCommandError(`V3 run-history route is not available on ${baseUrl}. Backend may not expose /api/runs.`, {
+                        code: 'RUN_HISTORY_UNAVAILABLE', status: resp.status, category: 'network',
+                    });
                 }
                 else {
-                    this.logger.error(`Failed to fetch runs: ${resp.status} ${resp.statusText}`);
+                    throw new CliCommandError(`Failed to fetch runs: ${resp.status} ${resp.statusText}`, {
+                        code: 'RUN_HISTORY_FAILED', status: resp.status,
+                    });
                 }
-                return;
             }
             const data = (await resp.json());
             spinner.stop();
             if (options.json) {
-                console.log(JSON.stringify(data, null, 2));
+                console.log(formatSuccessJson('history', data));
                 return;
             }
             if (data.runs.length === 0) {
@@ -107,7 +111,7 @@ export class HistoryCommand {
         }
         catch (err) {
             spinner.stop();
-            this.logger.error(`History error: ${err.message}`);
+            throw commandFailure(err, { code: 'RUN_HISTORY_FAILED' });
         }
     }
 }

package/dist/commands/hub.d.ts

@@ -8,8 +8,8 @@ import { Config } from '../utils/config.js';
 import { Logger } from '../utils/logger.js';
 export declare class HubCommand {
     private config;
-    private logger;
-    constructor(config: Config, logger: Logger);
+    constructor(config: Config, _logger: Logger);
+    private getAuthToken;
     /**
      * Search for modules by natural language query
      */

package/dist/commands/hub.js

@@ -5,13 +5,26 @@
  * Enables pay-as-you-go module usage directly from the terminal
  */
 import chalk from 'chalk';
+import { guardedFetch } from '../utils/network-policy.js';
+import { CliCommandError, commandFailure } from '../utils/command-contract.js';
 const API_BASE = 'https://api.vigthoria.io';
 export class HubCommand {
     config;
-    logger;
-    constructor(config, logger) {
+    constructor(config, _logger) {
         this.config = config;
-        this.logger = logger;
+    }
+    getAuthToken() {
+        const token = String(process.env.VIGTHORIA_TOKEN
+            || process.env.VIGTHORIA_AUTH_TOKEN
+            || this.config.get('authToken')
+            || '');
+        if (!token) {
+            throw new CliCommandError('Not authenticated. Run: vigthoria login', {
+                code: 'AUTH_REQUIRED',
+                category: 'authentication',
+            });
+        }
+        return token;
     }
     /**
      * Search for modules by natural language query
@@ -19,13 +32,13 @@ export class HubCommand {
     async search(query) {
         console.log(chalk.cyan('\n🔍 Searching Vigthoria Module Hub...\n'));
         try {
-            const response = await fetch(`${API_BASE}/api/modules/search`, {
+            const response = await guardedFetch(`${API_BASE}/api/modules/search`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json'
                 },
                 body: JSON.stringify({ query })
-            });
+            }, { audience: 'hub' });
             if (!response.ok) {
                 throw new Error(`Search failed: ${response.statusText}`);
             }
@@ -52,9 +65,7 @@ export class HubCommand {
             console.log(chalk.gray('Example: vigthoria hub activate music\n'));
         }
         catch (error) {
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`Error: ${errMsg}`));
-            console.log(chalk.gray('Make sure you have an active internet connection.'));
+            throw commandFailure(error, { code: 'HUB_SEARCH_FAILED' });
         }
     }
     /**
@@ -67,7 +78,10 @@ export class HubCommand {
             if (options.category) {
                 url += `?category=${options.category}`;
             }
-            const response = await fetch(url);
+            const response = await guardedFetch(url, {}, { audience: 'hub' });
+            if (!response.ok) {
+                throw new CliCommandError(`Failed to list modules: ${response.statusText}`, { code: 'HUB_LIST_FAILED', status: response.status });
+            }
             const data = await response.json();
             console.log(chalk.bold.white('Available Modules:\n'));
             // Group by category
@@ -95,28 +109,23 @@ export class HubCommand {
             console.log(chalk.gray('  vigthoria hub info <module>            - Module details\n'));
         }
         catch (error) {
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`Error: ${errMsg}`));
+            throw commandFailure(error, { code: 'HUB_LIST_FAILED' });
         }
     }
     /**
      * Activate a module for the current user
      */
     async activate(moduleId) {
-        const authToken = this.config.get('authToken');
-        if (!authToken) {
-            console.log(chalk.red('\n❌ Not authenticated. Run: vigthoria login\n'));
-            return;
-        }
+        const authToken = this.getAuthToken();
         console.log(chalk.cyan(`\n🔌 Activating module: ${moduleId}...\n`));
         try {
-            const response = await fetch(`${API_BASE}/api/modules/${moduleId}/activate`, {
+            const response = await guardedFetch(`${API_BASE}/api/modules/${moduleId}/activate`, {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${authToken}`,
                     'Content-Type': 'application/json'
                 }
-            });
+            }, { audience: 'hub' });
             if (!response.ok) {
                 const errorData = await response.json();
                 throw new Error(errorData.error || response.statusText);
@@ -139,28 +148,21 @@ export class HubCommand {
             console.log();
         }
         catch (error) {
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`❌ Activation failed: ${errMsg}`));
-            console.log(chalk.gray('\nMake sure the module ID is correct.'));
-            console.log(chalk.gray('Run: vigthoria hub list  to see available modules.'));
+            throw commandFailure(error, { code: 'HUB_ACTIVATION_FAILED' });
         }
     }
     /**
      * Show currently active modules for user
      */
     async active() {
-        const authToken = this.config.get('authToken');
-        if (!authToken) {
-            console.log(chalk.red('\n❌ Not authenticated. Run: vigthoria login\n'));
-            return;
-        }
+        const authToken = this.getAuthToken();
         console.log(chalk.cyan('\n📦 Your Active Modules\n'));
         try {
-            const response = await fetch(`${API_BASE}/api/modules/active`, {
+            const response = await guardedFetch(`${API_BASE}/api/modules/active`, {
                 headers: {
                     'Authorization': `Bearer ${authToken}`
                 }
-            });
+            }, { audience: 'hub' });
             if (!response.ok) {
                 throw new Error(`Failed to fetch: ${response.statusText}`);
             }
@@ -185,8 +187,7 @@ export class HubCommand {
             }
         }
         catch (error) {
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`Error: ${errMsg}`));
+            throw commandFailure(error, { code: 'HUB_ACTIVE_FAILED' });
         }
     }
     /**
@@ -195,7 +196,7 @@ export class HubCommand {
     async info(moduleId) {
         console.log(chalk.cyan(`\n📖 Module Info: ${moduleId}\n`));
         try {
-            const response = await fetch(`${API_BASE}/api/modules/${moduleId}`);
+            const response = await guardedFetch(`${API_BASE}/api/modules/${moduleId}`, {}, { audience: 'hub' });
             if (!response.ok) {
                 throw new Error('Module not found');
             }
@@ -250,9 +251,7 @@ export class HubCommand {
             console.log();
         }
         catch (error) {
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`Error: ${errMsg}`));
-            console.log(chalk.gray('\nAvailable modules: pay, meet, llm, music, voice, images'));
+            throw commandFailure(error, { code: 'HUB_INFO_FAILED' });
         }
     }
     /**

package/dist/commands/legion.d.ts

@@ -26,7 +26,6 @@ export declare class LegionCommand {
     private getHyperloopUrls;
     private getHeaders;
     private readJsonResponse;
-    private propagateLegionApiError;
     run(request: string | undefined, options: LegionOptions): Promise<void>;
     private runCortex;
     private isCriticalRoleFailure;