vigthoria-cli 1.6.55 → 1.6.57

package/dist/commands/fork.d.ts

@@ -0,0 +1,16 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface ForkOptions {
+    eventIndex?: number;
+    project?: string;
+    json?: boolean;
+}
+export declare class ForkCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private getHeaders;
+    private getBaseUrl;
+    run(runId: string, message: string, options: ForkOptions): Promise<void>;
+}
+export {};

package/dist/commands/fork.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForkCommand = void 0;
+/**
+ * fork.ts — Fork from an existing V3 agent run and stream the result.
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+class ForkCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = process.env.VIGTHORIA_TOKEN ||
+            process.env.VIGTHORIA_AUTH_TOKEN ||
+            this.config.get('authToken');
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['Cookie'] = `vigthoria-auth-token=${token}`;
+        }
+        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY;
+        if (serviceKey)
+            headers['X-Service-Key'] = serviceKey;
+        return headers;
+    }
+    getBaseUrl() {
+        return (process.env.VIGTHORIA_V3_AGENT_URL ||
+            process.env.V3_AGENT_URL ||
+            'http://127.0.0.1:8030');
+    }
+    async run(runId, message, options) {
+        const project = options.project || process.cwd();
+        const eventIndex = options.eventIndex || 0;
+        const spinner = (0, logger_js_1.createSpinner)(`Forking run ${runId}...`).start();
+        try {
+            const baseUrl = this.getBaseUrl();
+            const body = {
+                workspace_root: project,
+                from_event_index: eventIndex,
+                new_request: message || '',
+                stream: true,
+                context: '',
+            };
+            const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/fork`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify(body),
+            });
+            if (!resp.ok) {
+                spinner.stop();
+                if (resp.status === 404) {
+                    this.logger.error(`Run ${runId} not found or has no event log.`);
+                }
+                else {
+                    this.logger.error(`Fork failed: ${resp.status} ${resp.statusText}`);
+                }
+                return;
+            }
+            spinner.stop();
+            console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Forked from ${chalk_1.default.cyan(runId)} at event ${eventIndex}\n`));
+            if (!resp.body) {
+                this.logger.error('No response body');
+                return;
+            }
+            // 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();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const payload = line.slice(6).trim();
+                    if (payload === '[DONE]') {
+                        console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Fork run complete\n`));
+                        return;
+                    }
+                    try {
+                        const evt = JSON.parse(payload);
+                        const type = evt.type || 'unknown';
+                        if (options.json) {
+                            console.log(JSON.stringify(evt));
+                            continue;
+                        }
+                        switch (type) {
+                            case 'context':
+                                console.log(chalk_1.default.blue(`  context: ${evt.context_id || '?'}`) +
+                                    (evt.forked_from ? chalk_1.default.dim(` (forked from ${evt.forked_from})`) : ''));
+                                break;
+                            case 'start':
+                                console.log(chalk_1.default.green(`  ▶ START`) + ` task=${evt.task_id || '?'}` +
+                                    (evt.forked_from ? chalk_1.default.dim(` forked_from=${evt.forked_from}`) : ''));
+                                break;
+                            case 'plan':
+                                console.log(chalk_1.default.magenta(`  📋 PLAN`) + ` ${evt.tasks?.length || 0} tasks`);
+                                break;
+                            case 'tool_call':
+                                toolCallNum++;
+                                console.log(chalk_1.default.yellow(`  🔧 #${toolCallNum}`) + ` ${evt.name || '?'}(${JSON.stringify(evt.arguments || {}).substring(0, 60)})`);
+                                break;
+                            case 'tool_result': {
+                                const icon = evt.success !== false ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+                                console.log(`    ${icon} ${evt.name || '?'}: ${chalk_1.default.dim((evt.output || '').substring(0, 100))}`);
+                                break;
+                            }
+                            case 'message':
+                                console.log(chalk_1.default.cyan(`  💬 `) + (evt.content || '').substring(0, 150));
+                                break;
+                            case 'complete': {
+                                const seal = evt.seal_score ? `[${evt.seal_score.tier} ${evt.seal_score.overall}]` : '';
+                                console.log(chalk_1.default.green(`  ✅ COMPLETE `) + chalk_1.default.yellow(seal) +
+                                    ` ${evt.iterations || '?'} iterations, ${evt.tool_calls || '?'} tool calls`);
+                                break;
+                            }
+                            case 'error':
+                                console.log(chalk_1.default.red(`  ❌ ERROR: `) + (evt.message || '').substring(0, 200));
+                                break;
+                            default:
+                                console.log(chalk_1.default.dim(`  ${type}: ${JSON.stringify(evt).substring(0, 80)}`));
+                        }
+                    }
+                    catch {
+                        // skip unparseable lines
+                    }
+                }
+            }
+        }
+        catch (err) {
+            spinner.stop();
+            this.logger.error(`Fork error: ${err.message}`);
+        }
+    }
+}
+exports.ForkCommand = ForkCommand;

package/dist/commands/history.d.ts

@@ -0,0 +1,16 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface HistoryOptions {
+    limit?: number;
+    json?: boolean;
+    project?: string;
+}
+export declare class HistoryCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private getHeaders;
+    private getBaseUrl;
+    run(options: HistoryOptions): Promise<void>;
+}
+export {};

package/dist/commands/history.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryCommand = void 0;
+/**
+ * history.ts — List recent V3 agent runs with summaries.
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+class HistoryCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = process.env.VIGTHORIA_TOKEN ||
+            process.env.VIGTHORIA_AUTH_TOKEN ||
+            this.config.get('authToken');
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['Cookie'] = `vigthoria-auth-token=${token}`;
+        }
+        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY;
+        if (serviceKey)
+            headers['X-Service-Key'] = serviceKey;
+        return headers;
+    }
+    getBaseUrl() {
+        return (process.env.VIGTHORIA_V3_AGENT_URL ||
+            process.env.V3_AGENT_URL ||
+            'http://127.0.0.1:8030');
+    }
+    async run(options) {
+        const limit = options.limit || 20;
+        const project = options.project || process.cwd();
+        const spinner = (0, logger_js_1.createSpinner)('Loading run history...').start();
+        try {
+            const baseUrl = this.getBaseUrl();
+            const params = new URLSearchParams({
+                limit: String(limit),
+                workspace_root: project,
+            });
+            const resp = await fetch(`${baseUrl}/api/runs?${params}`, {
+                headers: this.getHeaders(),
+            });
+            if (!resp.ok) {
+                spinner.stop();
+                this.logger.error(`Failed to fetch runs: ${resp.status} ${resp.statusText}`);
+                return;
+            }
+            const data = (await resp.json());
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            if (data.runs.length === 0) {
+                this.logger.info(chalk_1.default.dim('No runs found.'));
+                return;
+            }
+            console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Recent Runs (${data.count})\n`));
+            for (const run of data.runs) {
+                const tier = run.seal_score?.tier || 'unknown';
+                const tierColor = tier === 'gold' ? chalk_1.default.yellow :
+                    tier === 'silver' ? chalk_1.default.white :
+                        tier === 'bronze' ? chalk_1.default.hex('#cd7f32') :
+                            tier === 'failed' ? chalk_1.default.red :
+                                chalk_1.default.dim;
+                const score = run.seal_score?.overall != null ? `${run.seal_score.overall}` : '—';
+                const status = run.failed > 0
+                    ? chalk_1.default.red(`${run.completed}/${run.task_count} ✗`)
+                    : chalk_1.default.green(`${run.completed}/${run.task_count} ✓`);
+                console.log(`  ${chalk_1.default.cyan(run.run_id.substring(0, 16))}  ` +
+                    `${chalk_1.default.dim(run.archived_at || '?')}  ` +
+                    `${status}  ` +
+                    `${tierColor(`[${tier} ${score}]`)}  ` +
+                    `${chalk_1.default.white(run.request?.substring(0, 60) || '(no request)')}`);
+            }
+            console.log();
+        }
+        catch (err) {
+            spinner.stop();
+            this.logger.error(`History error: ${err.message}`);
+        }
+    }
+}
+exports.HistoryCommand = HistoryCommand;

package/dist/commands/legion.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Vigthoria CLI - Legion Parallel Orchestration
+ *
+ * Submit work to Hyper Loop's Legion engine for parallel execution.
+ *
+ * Usage:
+ *   vigthoria legion "Refactor auth and update tests"
+ *   vigthoria legion --workers          List available Legion workers
+ *   vigthoria legion --status           Show Legion infrastructure status
+ */
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface LegionOptions {
+    workers?: boolean;
+    status?: boolean;
+    worker?: string;
+    project?: string;
+}
+export declare class LegionCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private getHeaders;
+    run(request: string | undefined, options: LegionOptions): Promise<void>;
+    private planAndExecute;
+    private showWorkers;
+    private showStatus;
+}
+export {};

package/dist/commands/legion.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Vigthoria CLI - Legion Parallel Orchestration
+ *
+ * Submit work to Hyper Loop's Legion engine for parallel execution.
+ *
+ * Usage:
+ *   vigthoria legion "Refactor auth and update tests"
+ *   vigthoria legion --workers          List available Legion workers
+ *   vigthoria legion --status           Show Legion infrastructure status
+ */
+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 logger_js_1 = require("../utils/logger.js");
+const HYPERLOOP_URLS = [
+    'http://localhost:8020/api/hyperloop',
+    'http://10.0.0.2:8020/api/hyperloop',
+];
+class LegionCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = this.config.get('authToken');
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['Cookie'] = `vigthoria-auth-token=${token}`;
+        }
+        return headers;
+    }
+    async run(request, options) {
+        if (options.workers) {
+            await this.showWorkers();
+            return;
+        }
+        if (options.status) {
+            await this.showStatus();
+            return;
+        }
+        if (!request) {
+            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'));
+            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 = {
+            request,
+            context: {
+                workspace: options.project || process.cwd(),
+            },
+            constraints: {},
+        };
+        for (const baseUrl of HYPERLOOP_URLS) {
+            try {
+                const response = await fetch(`${baseUrl}/legion/plan/execute`, {
+                    method: 'POST',
+                    headers: this.getHeaders(),
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(300000),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => '');
+                    throw new Error(`Legion API ${response.status}: ${errorText.slice(0, 200)}`);
+                }
+                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)}`) : ''}`);
+                        }
+                    }
+                }
+                // 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 (result.content) {
+                    console.log();
+                    console.log(chalk_1.default.white(String(result.content).slice(0, 500)));
+                }
+                console.log();
+                return;
+            }
+            catch (error) {
+                if (error?.name === 'AbortError') {
+                    spinner.stop();
+                    this.logger.error('Legion request timed out');
+                    return;
+                }
+                // Try next URL
+                continue;
+            }
+        }
+        spinner.stop();
+        this.logger.error('Could not reach Hyper Loop Legion API. Is vigthoria-hyper-loop running?');
+    }
+    async showWorkers() {
+        const spinner = (0, logger_js_1.createSpinner)('Fetching Legion worker catalog...').start();
+        for (const baseUrl of HYPERLOOP_URLS) {
+            try {
+                const response = await fetch(`${baseUrl}/legion/workers`, {
+                    signal: AbortSignal.timeout(10000),
+                    headers: this.getHeaders(),
+                });
+                if (!response.ok)
+                    continue;
+                const data = await response.json();
+                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)}`));
+                console.log();
+                const workers = data.workers || data.catalog || data;
+                if (Array.isArray(workers)) {
+                    for (const w of workers) {
+                        const wObj = w;
+                        const statusColor = wObj.status === 'active' ? chalk_1.default.green : chalk_1.default.yellow;
+                        console.log(`  ${statusColor(logger_js_1.CH.bullet)} ${chalk_1.default.white(wObj.name || wObj.worker || 'unknown')}  ${chalk_1.default.gray(wObj.description || '')}`);
+                        if (wObj.status) {
+                            console.log(chalk_1.default.gray(`    Status: ${wObj.status}`));
+                        }
+                    }
+                }
+                else if (typeof workers === 'object') {
+                    for (const [name, info] of Object.entries(workers)) {
+                        const infoObj = info;
+                        const statusColor = infoObj.maturity === 'active' ? chalk_1.default.green : chalk_1.default.yellow;
+                        console.log(`  ${statusColor(logger_js_1.CH.bullet)} ${chalk_1.default.white(name)}  ${chalk_1.default.gray(infoObj.description || '')}`);
+                        if (infoObj.maturity)
+                            console.log(chalk_1.default.gray(`    Maturity: ${infoObj.maturity}`));
+                        if (infoObj.domains)
+                            console.log(chalk_1.default.gray(`    Domains: ${Array.isArray(infoObj.domains) ? infoObj.domains.join(', ') : infoObj.domains}`));
+                    }
+                }
+                console.log();
+                return;
+            }
+            catch {
+                continue;
+            }
+        }
+        spinner.stop();
+        this.logger.error('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) {
+            try {
+                const response = await fetch(`${baseUrl}/status`, {
+                    signal: AbortSignal.timeout(10000),
+                    headers: this.getHeaders(),
+                });
+                if (!response.ok)
+                    continue;
+                const data = await response.json();
+                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)}`));
+                console.log();
+                console.log(chalk_1.default.gray(`  Hyper Loop: `) + chalk_1.default.green('online'));
+                if (data.workers || data.active_workers) {
+                    const count = data.workers || data.active_workers;
+                    console.log(chalk_1.default.gray(`  Active workers: `) + chalk_1.default.white(String(typeof count === 'number' ? count : Object.keys(count).length)));
+                }
+                if (data.remotes || data.infrastructure) {
+                    const remotes = data.remotes || data.infrastructure;
+                    if (typeof remotes === 'object') {
+                        for (const [name, status] of Object.entries(remotes)) {
+                            const icon = status?.reachable ? chalk_1.default.green(logger_js_1.CH.success) : chalk_1.default.red(logger_js_1.CH.error);
+                            console.log(`  ${icon} ${chalk_1.default.white(name)}`);
+                        }
+                    }
+                }
+                console.log();
+                return;
+            }
+            catch {
+                continue;
+            }
+        }
+        spinner.stop();
+        console.log();
+        console.log(chalk_1.default.gray('  Hyper Loop: ') + chalk_1.default.red('offline'));
+        console.log();
+    }
+}
+exports.LegionCommand = LegionCommand;

package/dist/commands/replay.d.ts

@@ -0,0 +1,17 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface ReplayOptions {
+    speed?: number;
+    json?: boolean;
+    project?: string;
+}
+export declare class ReplayCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private getHeaders;
+    private getBaseUrl;
+    private sleep;
+    run(runId: string, options: ReplayOptions): Promise<void>;
+}
+export {};

package/dist/commands/replay.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayCommand = void 0;
+/**
+ * replay.ts — Replay events from a V3 agent run step-by-step.
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+class ReplayCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = process.env.VIGTHORIA_TOKEN ||
+            process.env.VIGTHORIA_AUTH_TOKEN ||
+            this.config.get('authToken');
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['Cookie'] = `vigthoria-auth-token=${token}`;
+        }
+        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY;
+        if (serviceKey)
+            headers['X-Service-Key'] = serviceKey;
+        return headers;
+    }
+    getBaseUrl() {
+        return (process.env.VIGTHORIA_V3_AGENT_URL ||
+            process.env.V3_AGENT_URL ||
+            'http://127.0.0.1:8030');
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async run(runId, options) {
+        const speed = options.speed || 200;
+        const project = options.project || process.cwd();
+        const spinner = (0, logger_js_1.createSpinner)(`Loading events for run ${runId}...`).start();
+        try {
+            const baseUrl = this.getBaseUrl();
+            const params = new URLSearchParams({ workspace_root: project });
+            const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events?${params}`, {
+                headers: this.getHeaders(),
+            });
+            if (!resp.ok) {
+                spinner.stop();
+                if (resp.status === 404) {
+                    this.logger.error(`No event log found for run ${runId}. Events are only recorded for runs made after the replay system was deployed.`);
+                }
+                else {
+                    this.logger.error(`Failed to fetch events: ${resp.status} ${resp.statusText}`);
+                }
+                return;
+            }
+            const data = (await resp.json());
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Replaying run ${chalk_1.default.cyan(runId)} (${data.count} events)\n`));
+            let toolCallNum = 0;
+            for (let i = 0; i < data.events.length; i++) {
+                const evt = data.events[i];
+                const type = evt.type || 'unknown';
+                const idx = chalk_1.default.dim(`[${String(i + 1).padStart(3)}/${data.count}]`);
+                switch (type) {
+                    case 'context':
+                        console.log(`${idx} ${chalk_1.default.blue('context')} workspace=${evt.workspace_root || '?'}`);
+                        break;
+                    case 'start':
+                        console.log(`${idx} ${chalk_1.default.green('▶ START')} task=${evt.task_id || '?'} ${evt.continuation ? chalk_1.default.dim(`(continuation #${evt.continuation})`) : ''}`);
+                        break;
+                    case 'thinking':
+                        console.log(`${idx} ${chalk_1.default.dim('💭 thinking')} ${(evt.content || '').substring(0, 100)}`);
+                        break;
+                    case 'plan':
+                        const taskCount = evt.tasks?.length || 0;
+                        console.log(`${idx} ${chalk_1.default.magenta('📋 PLAN')} ${taskCount} tasks`);
+                        if (evt.tasks) {
+                            for (const t of evt.tasks.slice(0, 5)) {
+                                console.log(`       ${chalk_1.default.dim('├')} ${t.id || '?'}: ${(t.title || '').substring(0, 60)}`);
+                            }
+                            if (taskCount > 5)
+                                console.log(`       ${chalk_1.default.dim('└')} ...and ${taskCount - 5} more`);
+                        }
+                        break;
+                    case 'tool_call':
+                        toolCallNum++;
+                        console.log(`${idx} ${chalk_1.default.yellow(`🔧 tool_call #${toolCallNum}`)} ${chalk_1.default.bold(evt.name || '?')}(${JSON.stringify(evt.arguments || {}).substring(0, 80)})`);
+                        break;
+                    case 'tool_result': {
+                        const success = evt.success !== false;
+                        const icon = success ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+                        const output = (evt.output || '').substring(0, 120);
+                        console.log(`${idx}   ${icon} ${evt.name || '?'}: ${chalk_1.default.dim(output)}`);
+                        break;
+                    }
+                    case 'message':
+                        console.log(`${idx} ${chalk_1.default.cyan('💬 message')} ${(evt.content || '').substring(0, 120)}`);
+                        break;
+                    case 'complete': {
+                        const summary = (evt.summary || '').substring(0, 200);
+                        const seal = evt.seal_score ? ` [${evt.seal_score.tier} ${evt.seal_score.overall}]` : '';
+                        console.log(`${idx} ${chalk_1.default.green(`✅ COMPLETE`)}${chalk_1.default.yellow(seal)} ${evt.iterations || '?'} iterations, ${evt.tool_calls || '?'} tool calls`);
+                        if (summary)
+                            console.log(`       ${chalk_1.default.dim(summary)}`);
+                        break;
+                    }
+                    case 'error':
+                        console.log(`${idx} ${chalk_1.default.red('❌ ERROR')} ${(evt.message || '').substring(0, 200)}`);
+                        if (evt.checkpointed)
+                            console.log(`       ${chalk_1.default.yellow('Checkpointed — can be continued or forked')}`);
+                        break;
+                    case 'file_mutation':
+                        console.log(`${idx} ${chalk_1.default.blue('📁 file_mutation')} ${evt.kind || '?'} ${evt.path || '?'}`);
+                        break;
+                    default:
+                        console.log(`${idx} ${chalk_1.default.dim(type)} ${JSON.stringify(evt).substring(0, 100)}`);
+                }
+                // Delay between events for replay effect
+                if (i < data.events.length - 1) {
+                    await this.sleep(speed);
+                }
+            }
+            console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Replay complete (${data.count} events)\n`));
+        }
+        catch (err) {
+            spinner.stop();
+            this.logger.error(`Replay error: ${err.message}`);
+        }
+    }
+}
+exports.ReplayCommand = ReplayCommand;

package/dist/index.js

@@ -67,6 +67,10 @@ const deploy_js_1 = require("./commands/deploy.js");
 const bridge_js_1 = require("./commands/bridge.js");
 const workflow_js_1 = require("./commands/workflow.js");
 const preview_js_1 = require("./commands/preview.js");
+const legion_js_1 = require("./commands/legion.js");
+const history_js_1 = require("./commands/history.js");
+const replay_js_1 = require("./commands/replay.js");
+const fork_js_1 = require("./commands/fork.js");
 const config_js_2 = require("./utils/config.js");
 const logger_js_1 = require("./utils/logger.js");
 const chalk_1 = __importDefault(require("chalk"));
@@ -685,6 +689,55 @@ async function main() {
             screenshot: options.screenshot,
         });
     });
+    // ==================== LEGION COMMAND ====================
+    program
+        .command('legion [request]')
+        .description('Run parallel tasks via Hyper Loop Legion orchestrator')
+        .option('--workers', 'List available Legion workers')
+        .option('--status', 'Show Legion infrastructure status')
+        .option('-w, --worker <name>', 'Execute a specific worker')
+        .option('-p, --project <path>', 'Project directory', process.cwd())
+        .action(async (request, options) => {
+        const legion = new legion_js_1.LegionCommand(config, logger);
+        await legion.run(request, {
+            workers: options.workers,
+            status: options.status,
+            worker: options.worker,
+            project: options.project,
+        });
+    });
+    // ==================== REPLAY & FORK COMMANDS ====================
+    program
+        .command('history')
+        .alias('runs')
+        .description('List recent V3 agent runs')
+        .option('-n, --limit <count>', 'Number of runs to show', '20')
+        .option('-p, --project <path>', 'Project directory', process.cwd())
+        .option('--json', 'Machine-readable JSON output', false)
+        .action(async (options) => {
+        const history = new history_js_1.HistoryCommand(config, logger);
+        await history.run({ limit: parseInt(options.limit, 10) || 20, json: options.json, project: options.project });
+    });
+    program
+        .command('replay <runId>')
+        .description('Replay events from a V3 agent run step-by-step')
+        .option('-s, --speed <ms>', 'Delay between events in ms', '200')
+        .option('-p, --project <path>', 'Project directory', process.cwd())
+        .option('--json', 'Machine-readable JSON output', false)
+        .action(async (runId, options) => {
+        const replay = new replay_js_1.ReplayCommand(config, logger);
+        await replay.run(runId, { speed: parseInt(options.speed, 10) || 200, json: options.json, project: options.project });
+    });
+    program
+        .command('fork <runId> [message]')
+        .description('Fork from an existing V3 agent run with new instructions')
+        .option('-e, --event-index <index>', 'Fork from specific event index', '0')
+        .option('-p, --project <path>', 'Project directory', process.cwd())
+        .option('--json', 'Machine-readable JSON output', false)
+        .action(async (runId, message, options) => {
+        const fork = new fork_js_1.ForkCommand(config, logger);
+        await fork.run(runId, message || '', { eventIndex: parseInt(options.eventIndex, 10) || 0, project: options.project, json: options.json });
+    });
     // ==================== AUTH COMMANDS ====================
     // Auth commands
     program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.6.55",
+  "version": "1.6.57",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [