vigthoria-cli 1.6.5 → 1.6.9

package/dist/utils/api.js

@@ -9,8 +9,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APIClient = void 0;
 const axios_1 = __importDefault(require("axios"));
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
 const https_1 = __importDefault(require("https"));
+const net_1 = __importDefault(require("net"));
+const path_1 = __importDefault(require("path"));
 const ws_1 = __importDefault(require("ws"));
+const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
+    const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS || '1200000';
+    const parsed = Number.parseInt(rawValue, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1200000;
+})();
+const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
+    const rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS || '90000';
+    const parsed = Number.parseInt(rawValue, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
+})();
+const DEFAULT_OPERATOR_TIMEOUT_MS = (() => {
+    const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS || '1200000';
+    const parsed = Number.parseInt(rawValue, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1200000;
+})();
 class APIClient {
     client;
     modelRouterClient;
@@ -18,6 +37,7 @@ class APIClient {
     config;
     logger;
     ws = null;
+    vigFlowTokens = new Map();
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
@@ -34,7 +54,7 @@ class APIClient {
             httpsAgent,
             headers: {
                 'Content-Type': 'application/json',
-                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.5'}`,
+                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.9'}`,
             },
         });
         // Direct AI Models API - bypasses Coder for direct model access
@@ -45,18 +65,19 @@ class APIClient {
             httpsAgent,
             headers: {
                 'Content-Type': 'application/json',
-                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.5'}`,
+                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.9'}`,
             },
         });
-        // Self-hosted model router for Blackwell-backed agent fallback.
-        this.selfHostedModelRouterClient = axios_1.default.create({
-            baseURL: process.env.VIGTHORIA_SELF_HOSTED_MODELS_API_URL || 'http://127.0.0.1:4009',
+        // Self-hosted model router is opt-in only.
+        const selfHostedModelsApiUrl = this.getSelfHostedModelsApiUrl();
+        this.selfHostedModelRouterClient = selfHostedModelsApiUrl ? axios_1.default.create({
+            baseURL: selfHostedModelsApiUrl,
             timeout: 240000,
             headers: {
                 'Content-Type': 'application/json',
-                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.5'}`,
+                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.9'}`,
             },
-        });
+        }) : null;
         // Add auth interceptor
         this.client.interceptors.request.use((req) => {
             const token = this.config.get('authToken');
@@ -74,7 +95,7 @@ class APIClient {
             }
             return req;
         });
-        this.selfHostedModelRouterClient.interceptors.request.use((req) => {
+        this.selfHostedModelRouterClient?.interceptors.request.use((req) => {
             const token = this.config.get('authToken');
             if (token) {
                 req.headers.Authorization = `Bearer ${token}`;
@@ -92,6 +113,15 @@ class APIClient {
             throw error;
         });
     }
+    getSelfHostedModelsApiUrl() {
+        const configuredUrl = process.env.VIGTHORIA_SELF_HOSTED_MODELS_API_URL
+            || this.config.get('selfHostedModelsApiUrl');
+        if (!configuredUrl) {
+            return null;
+        }
+        const normalizedUrl = String(configuredUrl).trim().replace(/\/$/, '');
+        return normalizedUrl || null;
+    }
     // Authentication - Uses Vigthoria Coder /api/login endpoint
     async login(email, password) {
         try {
@@ -124,26 +154,42 @@ class APIClient {
         try {
             // Validate token by making a request to user info endpoint
             this.config.set('authToken', token);
-            const response = await this.client.get('/api/user/profile', {
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    Cookie: `vigthoria-auth-token=${token}`,
-                },
-            });
-            if (response.data && response.data.user) {
-                const user = response.data.user;
-                this.config.setAuth({
-                    token,
-                    userId: user.id,
-                    email: user.email,
-                });
-                this.config.setSubscription({
-                    plan: user.subscription?.plan || user.subscription_plan || 'developer',
-                    status: 'active',
-                    expiresAt: undefined,
-                });
-                return true;
+            const headers = {
+                Authorization: `Bearer ${token}`,
+                Cookie: `vigthoria-auth-token=${token}`,
+            };
+            const candidateEndpoints = [
+                '/api/user/profile',
+                '/api/user/info',
+                '/api/auth/me',
+            ];
+            for (const endpoint of candidateEndpoints) {
+                try {
+                    const response = await this.client.get(endpoint, { headers });
+                    const profile = this.extractUserProfile(response.data);
+                    if (!profile) {
+                        continue;
+                    }
+                    this.config.setAuth({
+                        token,
+                        userId: profile.id,
+                        email: profile.email,
+                    });
+                    this.config.setSubscription({
+                        plan: profile.plan,
+                        status: 'active',
+                        expiresAt: undefined,
+                    });
+                    return true;
+                }
+                catch (error) {
+                    const axiosError = error;
+                    if (axiosError.response?.status && axiosError.response.status !== 404) {
+                        throw error;
+                    }
+                }
             }
+            this.config.clearAuth();
             return false;
         }
         catch (error) {
@@ -152,6 +198,27 @@ class APIClient {
             return false;
         }
     }
+    extractUserProfile(data) {
+        if (!data) {
+            return null;
+        }
+        const rawUser = data.user || data;
+        const userId = rawUser.id;
+        const email = rawUser.email;
+        if (!userId || !email) {
+            return null;
+        }
+        const plan = data.subscription?.plan
+            || rawUser.subscription?.plan
+            || rawUser.subscription_plan
+            || data.subscription_plan
+            || 'developer';
+        return {
+            id: userId,
+            email,
+            plan,
+        };
+    }
     async refreshToken() {
         const refreshToken = this.config.get('refreshToken');
         if (!refreshToken)
@@ -186,6 +253,1393 @@ class APIClient {
             this.logger.debug('Failed to get subscription status:', error.message);
         }
     }
+    getAccessToken() {
+        return process.env.VIGTHORIA_TOKEN
+            || process.env.VIGTHORIA_AUTH_TOKEN
+            || this.config.get('authToken')
+            || null;
+    }
+    getV3AgentBaseUrls() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const urls = [
+            process.env.VIGTHORIA_V3_AGENT_URL,
+            process.env.V3_AGENT_URL,
+            'http://127.0.0.1:8030',
+            configuredApiUrl,
+        ].filter(Boolean).map((url) => String(url).replace(/\/$/, ''));
+        return [...new Set(urls)];
+    }
+    getV3AgentRunUrl(baseUrl) {
+        if (/127\.0\.0\.1:8030|localhost:8030/.test(baseUrl)) {
+            return `${baseUrl}/api/agent/run`;
+        }
+        return `${baseUrl}/api/v3-agent/run`;
+    }
+    getOperatorBaseUrls() {
+        const configuredModelsApiUrl = String(this.config.get('modelsApiUrl') || 'https://api.vigthoria.io').replace(/\/$/, '');
+        const urls = [
+            process.env.VIGTHORIA_OPERATOR_URL,
+            process.env.OPERATOR_URL,
+            'http://127.0.0.1:4009',
+            configuredModelsApiUrl,
+        ].filter(Boolean).map((url) => String(url).replace(/\/$/, ''));
+        return [...new Set(urls)];
+    }
+    getOperatorStreamUrl(baseUrl) {
+        return `${baseUrl}/api/operator/stream`;
+    }
+    getMcpBaseUrls() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const urls = [
+            process.env.VIGTHORIA_MCP_URL,
+            process.env.MCP_SERVER_URL,
+            'http://127.0.0.1:4008',
+            configuredApiUrl,
+        ].filter(Boolean).map((url) => String(url).replace(/\/$/, ''));
+        return [...new Set(urls)];
+    }
+    getVigFlowBaseUrls() {
+        const urls = [
+            process.env.VIGTHORIA_VIGFLOW_URL,
+            process.env.VIGFLOW_URL,
+            process.env.WORKFLOW_BUILDER_URL,
+            'http://127.0.0.1:5060',
+            'http://127.0.0.1:5050',
+        ].filter(Boolean).map((url) => String(url).replace(/\/$/, ''));
+        return [...new Set(urls)];
+    }
+    getTemplateServiceBaseUrls() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const urls = [
+            process.env.VIGTHORIA_TEMPLATE_SERVICE_URL,
+            process.env.TEMPLATE_SERVICE_URL,
+            'http://127.0.0.1:4011',
+            `${configuredApiUrl}/api/template-service`,
+        ].filter(Boolean).map((url) => String(url).replace(/\/$/, ''));
+        return [...new Set(urls)];
+    }
+    isFrontendTask(message = '', context = {}) {
+        const prompt = String(message || '');
+        const expectedFiles = this.extractExpectedWorkspaceFiles(message, context);
+        return /(premium|polished|landing|site|page|dashboard|saas|frontend|ui|pricing|showcase|hero|responsive)/i.test(prompt)
+            || expectedFiles.some((filePath) => /\.(html|css|js)$/i.test(filePath));
+    }
+    normalizeWorkspaceRelativePath(filePath) {
+        return String(filePath || '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
+    }
+    listFrontendWorkspaceFiles(rootPath) {
+        const results = [];
+        const stack = [rootPath];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (!current) {
+                continue;
+            }
+            for (const entry of fs_1.default.readdirSync(current, { withFileTypes: true })) {
+                if (entry.name === '.git' || entry.name === 'node_modules') {
+                    continue;
+                }
+                const fullPath = path_1.default.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(fullPath);
+                    continue;
+                }
+                if (!entry.isFile()) {
+                    continue;
+                }
+                const relativePath = this.normalizeWorkspaceRelativePath(path_1.default.relative(rootPath, fullPath));
+                if (relativePath) {
+                    results.push(relativePath);
+                }
+            }
+        }
+        results.sort((left, right) => left.localeCompare(right));
+        return results;
+    }
+    chooseFrontendPreviewEntry(rootPath, htmlPaths, expectedFiles = []) {
+        const normalizedExpected = expectedFiles
+            .map((filePath) => this.normalizeWorkspaceRelativePath(filePath))
+            .filter((filePath) => /\.html?$/i.test(filePath));
+        for (const expectedPath of normalizedExpected) {
+            if (htmlPaths.includes(expectedPath)) {
+                return expectedPath;
+            }
+        }
+        const scored = htmlPaths.map((relativePath) => {
+            const baseName = path_1.default.posix.basename(relativePath).toLowerCase();
+            const depth = relativePath.split('/').length - 1;
+            let score = 0;
+            if (relativePath.toLowerCase() === 'index.html') {
+                score += 200;
+            }
+            if (baseName === 'index.html') {
+                score += 120;
+            }
+            if (/(landing|home|main|dashboard|app)/i.test(baseName)) {
+                score += 60;
+            }
+            if (depth === 0) {
+                score += 40;
+            }
+            return { relativePath, score, depth };
+        }).sort((left, right) => right.score - left.score || left.depth - right.depth || left.relativePath.localeCompare(right.relativePath));
+        return scored[0]?.relativePath || null;
+    }
+    extractLinkedFrontendAssets(html, entryPath) {
+        const css = new Set();
+        const js = new Set();
+        const entryDir = path_1.default.posix.dirname(this.normalizeWorkspaceRelativePath(entryPath) || '.');
+        const normalizeAsset = (assetPath) => {
+            const clean = String(assetPath || '').trim();
+            if (!clean || clean.startsWith('http://') || clean.startsWith('https://') || clean.startsWith('//') || clean.startsWith('data:') || clean.startsWith('#')) {
+                return null;
+            }
+            const withoutQuery = clean.split('?')[0].split('#')[0];
+            if (!withoutQuery) {
+                return null;
+            }
+            if (withoutQuery.startsWith('/')) {
+                return this.normalizeWorkspaceRelativePath(withoutQuery.slice(1));
+            }
+            return this.normalizeWorkspaceRelativePath(path_1.default.posix.normalize(path_1.default.posix.join(entryDir, withoutQuery)));
+        };
+        const cssPattern = /<link[^>]+href=["']([^"']+\.css(?:[?#][^"']*)?)["'][^>]*>/gi;
+        const jsPattern = /<script[^>]+src=["']([^"']+\.(?:js|mjs|cjs)(?:[?#][^"']*)?)["'][^>]*>/gi;
+        let match;
+        while ((match = cssPattern.exec(String(html || ''))) !== null) {
+            const resolved = normalizeAsset(match[1]);
+            if (resolved) {
+                css.add(resolved);
+            }
+        }
+        while ((match = jsPattern.exec(String(html || ''))) !== null) {
+            const resolved = normalizeAsset(match[1]);
+            if (resolved) {
+                js.add(resolved);
+            }
+        }
+        return {
+            css: Array.from(css),
+            js: Array.from(js),
+        };
+    }
+    gatherFrontendPreviewArtifacts(message = '', context = {}) {
+        const rootPath = this.resolveAgentTargetPath(context);
+        if (!rootPath || !fs_1.default.existsSync(rootPath)) {
+            return { error: 'Frontend preview gate requires a readable project workspace.' };
+        }
+        const workspaceFiles = this.listFrontendWorkspaceFiles(rootPath);
+        const expectedFiles = this.extractExpectedWorkspaceFiles(message, context);
+        const htmlPaths = workspaceFiles.filter((filePath) => /\.html?$/i.test(filePath));
+        if (htmlPaths.length === 0) {
+            return { error: 'Frontend preview gate requires at least one HTML entry file in the workspace.' };
+        }
+        const htmlPath = this.chooseFrontendPreviewEntry(rootPath, htmlPaths, expectedFiles);
+        if (!htmlPath) {
+            return { error: 'Frontend preview gate could not determine a primary HTML entry file.' };
+        }
+        const html = fs_1.default.readFileSync(path_1.default.join(rootPath, htmlPath), 'utf8');
+        const linkedAssets = this.extractLinkedFrontendAssets(html, htmlPath);
+        const cssFiles = workspaceFiles.filter((filePath) => /\.css$/i.test(filePath));
+        const jsFiles = workspaceFiles.filter((filePath) => /\.(?:js|mjs|cjs)$/i.test(filePath));
+        const expectedCss = expectedFiles
+            .map((filePath) => this.normalizeWorkspaceRelativePath(filePath))
+            .filter((filePath) => /\.css$/i.test(filePath));
+        const expectedJs = expectedFiles
+            .map((filePath) => this.normalizeWorkspaceRelativePath(filePath))
+            .filter((filePath) => /\.(?:js|mjs|cjs)$/i.test(filePath));
+        const chooseExisting = (candidates, fallback) => {
+            const selected = new Set();
+            for (const candidate of [...candidates, ...fallback]) {
+                const normalized = this.normalizeWorkspaceRelativePath(candidate);
+                if (!normalized || selected.has(normalized)) {
+                    continue;
+                }
+                if (!fs_1.default.existsSync(path_1.default.join(rootPath, normalized))) {
+                    continue;
+                }
+                selected.add(normalized);
+            }
+            return Array.from(selected);
+        };
+        const selectedCssFiles = chooseExisting(linkedAssets.css, [...expectedCss, ...cssFiles]).slice(0, 12);
+        const selectedJsFiles = chooseExisting(linkedAssets.js, [...expectedJs, ...jsFiles]).slice(0, 12);
+        const css = selectedCssFiles.map((filePath) => fs_1.default.readFileSync(path_1.default.join(rootPath, filePath), 'utf8')).join('\n\n');
+        const js = selectedJsFiles.map((filePath) => fs_1.default.readFileSync(path_1.default.join(rootPath, filePath), 'utf8')).join('\n\n');
+        return { htmlPath, html, css, js, cssPaths: selectedCssFiles, jsPaths: selectedJsFiles };
+    }
+    async captureFrontendPreviewScreenshot(entryAbsolutePath, screenshotPath) {
+        try {
+            const puppeteerModule = await import('puppeteer').catch(() => null);
+            const puppeteer = puppeteerModule?.default || puppeteerModule;
+            if (!puppeteer || typeof puppeteer.launch !== 'function') {
+                return { captured: false, error: 'puppeteer-unavailable' };
+            }
+            const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox', '--disable-setuid-sandbox'] });
+            try {
+                const page = await browser.newPage();
+                await page.setViewport({ width: 1440, height: 960, deviceScaleFactor: 1 });
+                await page.goto(`file://${entryAbsolutePath}`, { waitUntil: 'networkidle0', timeout: 20000 });
+                await page.screenshot({ path: screenshotPath, fullPage: true });
+            }
+            finally {
+                await browser.close();
+            }
+            return { captured: true };
+        }
+        catch (error) {
+            return { captured: false, error: error?.message || String(error) };
+        }
+    }
+    evaluateFrontendVisualProof(summary = {}, artifacts = {}) {
+        const reasons = [];
+        const cssPaths = Array.isArray(artifacts.cssPaths) ? artifacts.cssPaths : [];
+        const html = String(artifacts.html || '');
+        const css = String(artifacts.css || '');
+        const js = String(artifacts.js || '');
+        if (!summary.hasViewportMeta) {
+            reasons.push('missing viewport metadata');
+        }
+        const hasStyleEvidence = cssPaths.length > 0 || /<style[\s>]/i.test(html) || css.trim().length > 0;
+        if (!hasStyleEvidence) {
+            reasons.push('missing stylesheet or inline style evidence');
+        }
+        const hasInteractionOrResponsiveEvidence = Boolean(summary.hasResponsiveSignals) || Boolean(summary.hasInteractiveSignals) || /<script[\s>]/i.test(html) || js.trim().length > 0;
+        if (!hasInteractionOrResponsiveEvidence) {
+            reasons.push('missing responsive or interactive evidence');
+        }
+        return {
+            ok: reasons.length === 0,
+            reasons,
+        };
+    }
+    async persistFrontendPreviewArtifacts(previewGate, rootPath, context = {}) {
+        if (!previewGate.required || !previewGate.entryPath) {
+            return previewGate;
+        }
+        try {
+            const artifactsDir = path_1.default.join(rootPath, '.vigthoria', 'proof', 'preview');
+            fs_1.default.mkdirSync(artifactsDir, { recursive: true });
+            const contextId = String(context.contextId || 'preview').trim() || 'preview';
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const baseName = `${timestamp}-${contextId}`;
+            const manifestPath = path_1.default.join(artifactsDir, `${baseName}.json`);
+            const screenshotPath = path_1.default.join(artifactsDir, `${baseName}.png`);
+            const entryAbsolutePath = path_1.default.join(rootPath, previewGate.entryPath);
+            const previewFileUrl = `file://${entryAbsolutePath}`;
+            const screenshot = await this.captureFrontendPreviewScreenshot(entryAbsolutePath, screenshotPath);
+            const manifest = {
+                schemaVersion: 1,
+                createdAt: new Date().toISOString(),
+                contextId: context.contextId || null,
+                workspaceRoot: rootPath,
+                entryPath: previewGate.entryPath,
+                previewFileUrl,
+                previewCommand: `vigthoria preview -p ${rootPath}`,
+                previewGate,
+                validationArtifacts: {
+                    summary: previewGate.summary || {},
+                    modes: previewGate.modes || {},
+                    backendUrl: previewGate.backendUrl || null,
+                    processingTimeMs: previewGate.processingTimeMs || null,
+                    assetPaths: previewGate.assetPaths || { css: [], js: [] },
+                },
+                screenshot: {
+                    path: screenshot.captured ? screenshotPath : null,
+                    captured: screenshot.captured,
+                    error: screenshot.error || null,
+                },
+            };
+            fs_1.default.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+            return {
+                ...previewGate,
+                artifacts: {
+                    manifestPath,
+                    screenshotPath: screenshot.captured ? screenshotPath : undefined,
+                    previewFileUrl,
+                    screenshotCaptured: screenshot.captured,
+                    screenshotError: screenshot.error,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                ...previewGate,
+                artifacts: {
+                    ...(previewGate.artifacts || {}),
+                    screenshotCaptured: false,
+                    screenshotError: error?.message || String(error),
+                },
+            };
+        }
+    }
+    async runTemplateServicePreviewGate(message = '', context = {}) {
+        if (!this.isFrontendTask(message, context)) {
+            return { required: false, passed: true };
+        }
+        const rootPath = this.resolveAgentTargetPath(context);
+        const artifacts = this.gatherFrontendPreviewArtifacts(message, context);
+        if (artifacts.error || !artifacts.htmlPath || typeof artifacts.html !== 'string') {
+            return {
+                required: true,
+                passed: false,
+                error: artifacts.error || 'Frontend preview gate could not collect frontend artifacts.',
+            };
+        }
+        const html = artifacts.html;
+        const css = artifacts.css || '';
+        const js = artifacts.js || '';
+        const errors = [];
+        for (const baseUrl of this.getTemplateServiceBaseUrls()) {
+            try {
+                const response = await fetch(`${baseUrl}/preview-proof`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json',
+                    },
+                    body: JSON.stringify({
+                        vision: String(context.rawPrompt || message || ''),
+                        html,
+                        css,
+                        js,
+                        entryPath: artifacts.htmlPath,
+                        workspaceName: path_1.default.basename(rootPath),
+                    }),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => '');
+                    throw new Error(`Template preview proof ${response.status}: ${errorText.slice(0, 200)}`);
+                }
+                const payload = await response.json();
+                const modes = payload?.modes || {};
+                const summary = payload?.summary || {};
+                const visualProof = this.evaluateFrontendVisualProof(summary, artifacts);
+                const passed = payload?.success === true
+                    && modes?.design?.ready === true
+                    && modes?.live?.ready === true
+                    && modes?.production?.ready === true
+                    && visualProof.ok;
+                const previewGate = {
+                    required: true,
+                    passed,
+                    backendUrl: baseUrl,
+                    entryPath: artifacts.htmlPath,
+                    assetPaths: {
+                        css: artifacts.cssPaths || [],
+                        js: artifacts.jsPaths || [],
+                    },
+                    modes,
+                    summary,
+                    processingTimeMs: Number(payload?.processing_time || 0) || undefined,
+                    error: passed ? undefined : (visualProof.ok ? 'Template Service preview modes did not all report ready.' : `Frontend preview proof is missing required visual evidence: ${visualProof.reasons.join(', ')}.`),
+                };
+                return await this.persistFrontendPreviewArtifacts(previewGate, rootPath, context);
+            }
+            catch (error) {
+                errors.push(`${baseUrl}: ${error?.message || String(error)}`);
+            }
+        }
+        return await this.persistFrontendPreviewArtifacts({
+            required: true,
+            passed: false,
+            entryPath: artifacts.htmlPath,
+            assetPaths: {
+                css: artifacts.cssPaths || [],
+                js: artifacts.jsPaths || [],
+            },
+            error: errors.join(' | ') || 'No Template Service preview endpoint was reachable.',
+        }, rootPath, context);
+    }
+    getMcpContextCreateUrl(baseUrl) {
+        return `${baseUrl}/mcp/context/create`;
+    }
+    getMcpContextUrl(baseUrl, contextId) {
+        return `${baseUrl}/mcp/context/${encodeURIComponent(contextId)}`;
+    }
+    async getMcpHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        };
+        const authToken = this.getAccessToken();
+        if (authToken) {
+            headers.Authorization = `Bearer ${authToken}`;
+            headers.Cookie = `vigthoria-auth-token=${authToken}`;
+        }
+        return headers;
+    }
+    async getV3AgentHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const authToken = this.getAccessToken();
+        if (authToken) {
+            headers.Authorization = `Bearer ${authToken}`;
+            headers.Cookie = `vigthoria-auth-token=${authToken}`;
+        }
+        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY
+            || process.env.V3_SERVICE_KEY
+            || process.env.HYPERLOOP_SERVICE_KEY;
+        if (serviceKey) {
+            headers['X-Service-Key'] = serviceKey;
+        }
+        return headers;
+    }
+    async executeV3AgentRunRequest(baseUrl, body, executionContext, signal) {
+        const makeRequest = async () => {
+            const headers = await this.getV3AgentHeaders();
+            if (executionContext.mcpContextId) {
+                headers['X-MCP-Context-Id'] = String(executionContext.mcpContextId);
+            }
+            return fetch(this.getV3AgentRunUrl(baseUrl), {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal,
+            });
+        };
+        let response = await makeRequest();
+        if (response.status !== 401) {
+            return response;
+        }
+        const refreshed = await this.refreshToken();
+        if (!refreshed) {
+            return response;
+        }
+        response = await makeRequest();
+        return response;
+    }
+    async getVigFlowAccessToken(baseUrl) {
+        const cachedToken = this.vigFlowTokens.get(baseUrl);
+        if (cachedToken) {
+            return cachedToken;
+        }
+        const authToken = this.getAccessToken();
+        if (!authToken) {
+            throw new Error('Not authenticated. Run vigthoria login first.');
+        }
+        const response = await axios_1.default.post(`${baseUrl}/api/auth/sso`, { token: authToken }, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            timeout: 30000,
+        });
+        const payload = response.data;
+        const vigFlowToken = String(payload.token || '').trim();
+        if (!vigFlowToken) {
+            throw new Error('VigFlow SSO response did not include a token.');
+        }
+        this.vigFlowTokens.set(baseUrl, vigFlowToken);
+        return vigFlowToken;
+    }
+    async getVigFlowHeaders(baseUrl) {
+        const token = await this.getVigFlowAccessToken(baseUrl);
+        return {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            Authorization: `Bearer ${token}`,
+        };
+    }
+    async withVigFlow(operation, action) {
+        let lastError = null;
+        for (const baseUrl of this.getVigFlowBaseUrls()) {
+            try {
+                const headers = await this.getVigFlowHeaders(baseUrl);
+                return await action(baseUrl, headers);
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.debug(`VigFlow ${operation} via ${baseUrl} failed:`, lastError.message);
+            }
+        }
+        throw lastError || new Error(`No VigFlow backend available for ${operation}.`);
+    }
+    async listVigFlowTemplates(options = {}) {
+        return this.withVigFlow('list templates', async (baseUrl, headers) => {
+            const query = new URLSearchParams();
+            if (options.category) {
+                query.set('category', options.category);
+            }
+            if (options.search) {
+                query.set('search', options.search);
+            }
+            const url = `${baseUrl}/api/templates${query.size > 0 ? `?${query.toString()}` : ''}`;
+            const response = await axios_1.default.get(url, {
+                headers,
+                timeout: 30000,
+            });
+            const payload = response.data;
+            return Array.isArray(payload.templates) ? payload.templates : [];
+        });
+    }
+    async listVigFlowWorkflows() {
+        return this.withVigFlow('list workflows', async (baseUrl, headers) => {
+            const response = await axios_1.default.get(`${baseUrl}/api/workflows`, {
+                headers,
+                timeout: 30000,
+            });
+            const payload = response.data;
+            return Array.isArray(payload.workflows) ? payload.workflows : [];
+        });
+    }
+    async resolveVigFlowWorkflow(selector) {
+        const normalizedSelector = String(selector || '').trim();
+        if (!normalizedSelector) {
+            throw new Error('Workflow selector is required. Provide a workflow id or name.');
+        }
+        const workflows = await this.listVigFlowWorkflows();
+        const byId = workflows.find((workflow) => workflow.id === normalizedSelector);
+        if (byId) {
+            return {
+                id: byId.id,
+                name: byId.name,
+                selector: normalizedSelector,
+                matchedBy: 'id',
+            };
+        }
+        const loweredSelector = normalizedSelector.toLowerCase();
+        const exactNameMatches = workflows.filter((workflow) => String(workflow.name || '').trim().toLowerCase() === loweredSelector);
+        if (exactNameMatches.length === 1) {
+            return {
+                id: exactNameMatches[0].id,
+                name: exactNameMatches[0].name,
+                selector: normalizedSelector,
+                matchedBy: 'name',
+            };
+        }
+        if (exactNameMatches.length > 1) {
+            throw new Error(`Multiple workflows matched the name "${normalizedSelector}". Use the workflow id instead.`);
+        }
+        const searchMatches = workflows.filter((workflow) => String(workflow.name || '').toLowerCase().includes(loweredSelector));
+        if (searchMatches.length === 1) {
+            return {
+                id: searchMatches[0].id,
+                name: searchMatches[0].name,
+                selector: normalizedSelector,
+                matchedBy: 'search',
+            };
+        }
+        if (searchMatches.length > 1) {
+            throw new Error(`Multiple workflows partially matched "${normalizedSelector}". Use a full workflow name or id.`);
+        }
+        throw new Error(`No VigFlow workflow matched "${normalizedSelector}".`);
+    }
+    async useVigFlowTemplate(templateId, options = {}) {
+        return this.withVigFlow('use template', async (baseUrl, headers) => {
+            const response = await axios_1.default.post(`${baseUrl}/api/templates/${encodeURIComponent(templateId)}/use`, {
+                name: options.name,
+                variables: options.variables || {},
+            }, {
+                headers,
+                timeout: 30000,
+            });
+            const payload = response.data;
+            if (!payload.workflow?.id) {
+                throw new Error('VigFlow use-template response did not include a workflow id.');
+            }
+            return payload.workflow;
+        });
+    }
+    async runVigFlowWorkflow(workflowId, options = {}) {
+        return this.withVigFlow('run workflow', async (baseUrl, headers) => {
+            const response = await axios_1.default.post(`${baseUrl}/api/executions/run/${encodeURIComponent(workflowId)}`, {
+                data: options.data || {},
+                options: options.executionOptions || {},
+            }, {
+                headers,
+                timeout: 60000,
+            });
+            const payload = response.data;
+            if (!payload.executionId) {
+                throw new Error('VigFlow run response did not include an execution id.');
+            }
+            return payload;
+        });
+    }
+    async getVigFlowExecutionStatus(executionId) {
+        return this.withVigFlow('execution status', async (baseUrl, headers) => {
+            const response = await axios_1.default.get(`${baseUrl}/api/executions/${encodeURIComponent(executionId)}`, {
+                headers,
+                timeout: 30000,
+            });
+            const payload = response.data;
+            if (!payload.execution?.id) {
+                throw new Error('VigFlow execution response did not include execution details.');
+            }
+            return payload.execution;
+        });
+    }
+    buildV3AgentContext(context = {}) {
+        const resolvedContext = this.ensureExecutionContext(context);
+        const targetPath = resolvedContext.targetPath || resolvedContext.projectPath || resolvedContext.workspacePath || resolvedContext.projectRoot || process.cwd();
+        return JSON.stringify({
+            workspace: resolvedContext.workspace || null,
+            activeFile: resolvedContext.activeFile || null,
+            history: resolvedContext.history || [],
+            agentTaskType: resolvedContext.agentTaskType || 'general',
+            executionSurface: resolvedContext.executionSurface || 'cli',
+            clientSurface: resolvedContext.clientSurface || 'cli',
+            localMachineCapable: resolvedContext.localMachineCapable !== false,
+            workspacePath: resolvedContext.workspacePath || targetPath,
+            projectPath: resolvedContext.projectPath || targetPath,
+            targetPath,
+            contextId: resolvedContext.contextId,
+            traceId: resolvedContext.traceId,
+            mcpContextId: resolvedContext.mcpContextId || null,
+            mcp_context_id: resolvedContext.mcpContextId || null,
+            requestStartedAt: resolvedContext.requestStartedAt,
+        });
+    }
+    ensureExecutionContext(context = {}) {
+        const existingId = String(context.contextId || context.traceId || '').trim();
+        const contextId = existingId || `vig-${Date.now()}-${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+        return {
+            ...context,
+            contextId,
+            traceId: context.traceId || contextId,
+            requestStartedAt: context.requestStartedAt || new Date().toISOString(),
+        };
+    }
+    async bindExecutionContext(context = {}) {
+        const executionContext = this.ensureExecutionContext(context);
+        const headers = await this.getMcpHeaders();
+        const workspacePath = executionContext.workspacePath || executionContext.projectPath || executionContext.targetPath || process.cwd();
+        const metadata = {
+            source: 'vigthoria-cli',
+            sharedContextId: executionContext.contextId,
+            traceId: executionContext.traceId,
+            executionSurface: executionContext.executionSurface || 'cli',
+            clientSurface: executionContext.clientSurface || 'cli',
+            workspacePath,
+            requestStartedAt: executionContext.requestStartedAt,
+            subscriptionPlan: this.config.getNormalizedPlan() || null,
+            email: this.config.get('email') || null,
+        };
+        const data = {
+            sharedContextId: executionContext.contextId,
+            traceId: executionContext.traceId,
+            requestStartedAt: executionContext.requestStartedAt,
+            workspacePath,
+            projectPath: executionContext.projectPath || workspacePath,
+            targetPath: executionContext.targetPath || workspacePath,
+            activeFile: executionContext.activeFile || null,
+            executionSurface: executionContext.executionSurface || 'cli',
+            clientSurface: executionContext.clientSurface || 'cli',
+            userId: this.config.get('userId') || null,
+            email: this.config.get('email') || null,
+        };
+        const updateExisting = async (binding) => {
+            const response = await fetch(this.getMcpContextUrl(binding.backendUrl, binding.mcpContextId), {
+                method: 'PUT',
+                headers,
+                body: JSON.stringify({ data }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => '');
+                throw new Error(`MCP context update ${response.status}: ${errorText.slice(0, 200)}`);
+            }
+            return {
+                ...executionContext,
+                mcpContextId: binding.mcpContextId,
+                mcpContextBackendUrl: binding.backendUrl,
+            };
+        };
+        if (executionContext.mcpContextId && executionContext.mcpContextBackendUrl) {
+            try {
+                return await updateExisting({
+                    mcpContextId: String(executionContext.mcpContextId),
+                    backendUrl: String(executionContext.mcpContextBackendUrl),
+                });
+            }
+            catch (error) {
+                this.logger.debug('Failed to refresh existing MCP context binding:', error.message);
+            }
+        }
+        for (const baseUrl of this.getMcpBaseUrls()) {
+            try {
+                const createResponse = await fetch(this.getMcpContextCreateUrl(baseUrl), {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        userId: this.config.get('userId') || this.config.get('email') || 'vigthoria-cli',
+                        metadata,
+                    }),
+                });
+                if (!createResponse.ok) {
+                    const errorText = await createResponse.text().catch(() => '');
+                    throw new Error(`MCP context create ${createResponse.status}: ${errorText.slice(0, 200)}`);
+                }
+                const payload = await createResponse.json();
+                const mcpContextId = String(payload.contextId || '').trim();
+                if (!mcpContextId) {
+                    throw new Error('MCP context create response did not include a contextId');
+                }
+                return await updateExisting({ mcpContextId, backendUrl: baseUrl });
+            }
+            catch (error) {
+                this.logger.debug(`Failed to bind MCP context via ${baseUrl}:`, error.message);
+            }
+        }
+        return executionContext;
+    }
+    resolveAgentTargetPath(context = {}) {
+        return context.targetPath || context.projectPath || context.workspacePath || context.projectRoot || process.cwd();
+    }
+    hasAgentWorkspaceOutput(context = {}) {
+        try {
+            const root = this.resolveAgentTargetPath(context);
+            if (!root || !fs_1.default.existsSync(root)) {
+                return false;
+            }
+            const stack = [root];
+            while (stack.length > 0) {
+                const current = stack.pop();
+                if (!current)
+                    continue;
+                const entries = fs_1.default.readdirSync(current, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name === '.git' || entry.name === 'node_modules') {
+                        continue;
+                    }
+                    const fullPath = path_1.default.join(current, entry.name);
+                    if (entry.isFile()) {
+                        return true;
+                    }
+                    if (entry.isDirectory()) {
+                        stack.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch {
+            return false;
+        }
+        return false;
+    }
+    getAgentWorkspaceSnapshot(rootPath) {
+        const stack = [rootPath];
+        let fileCount = 0;
+        const entries = [];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (!current) {
+                continue;
+            }
+            for (const entry of fs_1.default.readdirSync(current, { withFileTypes: true })) {
+                if (entry.name === '.git' || entry.name === 'node_modules') {
+                    continue;
+                }
+                const fullPath = path_1.default.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(fullPath);
+                    continue;
+                }
+                if (!entry.isFile()) {
+                    continue;
+                }
+                fileCount += 1;
+                const stat = fs_1.default.statSync(fullPath);
+                entries.push(`${path_1.default.relative(rootPath, fullPath)}:${stat.size}:${stat.mtimeMs}`);
+            }
+        }
+        entries.sort();
+        return {
+            fileCount,
+            paths: entries.map((entry) => entry.split(':', 1)[0]),
+            signature: entries.join('|'),
+        };
+    }
+    async waitForAgentWorkspaceSettle(context = {}, options = {}) {
+        const rootPath = this.resolveAgentTargetPath(context);
+        if (!rootPath || !fs_1.default.existsSync(rootPath)) {
+            return;
+        }
+        const timeoutMs = options.timeoutMs || 15000;
+        const pollMs = options.pollMs || 300;
+        const stableMs = options.stableMs || 1200;
+        const expectedFiles = Array.isArray(options.expectedFiles)
+            ? options.expectedFiles.map((entry) => String(entry || '').trim()).filter(Boolean)
+            : [];
+        const start = Date.now();
+        let stableSince = 0;
+        let lastSignature = '';
+        while (Date.now() - start < timeoutMs) {
+            const snapshot = this.getAgentWorkspaceSnapshot(rootPath);
+            if (snapshot.fileCount === 0) {
+                stableSince = 0;
+                lastSignature = '';
+                await new Promise((resolve) => setTimeout(resolve, pollMs));
+                continue;
+            }
+            if (expectedFiles.length > 0 && !expectedFiles.every((filePath) => snapshot.paths.includes(filePath))) {
+                stableSince = 0;
+                lastSignature = snapshot.signature;
+                await new Promise((resolve) => setTimeout(resolve, pollMs));
+                continue;
+            }
+            if (snapshot.signature === lastSignature) {
+                if (!stableSince) {
+                    stableSince = Date.now();
+                }
+                if (Date.now() - stableSince >= stableMs) {
+                    return;
+                }
+            }
+            else {
+                lastSignature = snapshot.signature;
+                stableSince = Date.now();
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollMs));
+        }
+    }
+    extractExpectedWorkspaceFiles(message = '', context = {}) {
+        const candidates = new Set();
+        const addMatches = (value) => {
+            const text = String(value || '');
+            const patterns = [
+                /`([^`]+\.(?:html|css|js|jsx|ts|tsx|json|md|py|sh))`/gi,
+                /\b([A-Za-z0-9_./-]+\.(?:html|css|js|jsx|ts|tsx|json|md|py|sh))\b/g,
+            ];
+            for (const pattern of patterns) {
+                let match;
+                while ((match = pattern.exec(text)) !== null) {
+                    const filePath = match[1].trim().replace(/^\.\//, '');
+                    if (filePath && !filePath.startsWith('http://') && !filePath.startsWith('https://')) {
+                        candidates.add(filePath);
+                    }
+                }
+            }
+        };
+        addMatches(message);
+        addMatches(context.rawMessage);
+        addMatches(context.agentPrompt);
+        return Array.from(candidates);
+    }
+    captureV3AgentStreamMutation(event, streamedFiles) {
+        if (!event || event.type !== 'tool_call' || !streamedFiles) {
+            return;
+        }
+        const args = event.arguments || {};
+        if ((event.name === 'write_file' || event.name === 'edit_file') && typeof args.path === 'string') {
+            const filePath = args.path.trim().replace(/\\/g, '/').replace(/^\.\//, '');
+            if (!filePath) {
+                return;
+            }
+            if (event.name === 'write_file' && typeof args.content === 'string') {
+                streamedFiles[filePath] = args.content;
+                return;
+            }
+            if (event.name === 'edit_file' && typeof args.old_string === 'string' && typeof args.new_string === 'string') {
+                const existing = streamedFiles[filePath];
+                if (typeof existing === 'string' && existing.includes(args.old_string)) {
+                    streamedFiles[filePath] = existing.replace(args.old_string, args.new_string);
+                }
+            }
+        }
+    }
+    recoverAgentWorkspaceFiles(context = {}, streamedFiles = {}, expectedFiles = []) {
+        const rootPath = this.resolveAgentTargetPath(context);
+        if (!rootPath || !fs_1.default.existsSync(rootPath) || Object.keys(streamedFiles).length === 0) {
+            return;
+        }
+        const targets = expectedFiles.length > 0 ? expectedFiles : Object.keys(streamedFiles);
+        for (const relativePath of targets) {
+            const content = streamedFiles[relativePath];
+            if (typeof content !== 'string') {
+                continue;
+            }
+            const absolutePath = path_1.default.join(rootPath, relativePath);
+            if (fs_1.default.existsSync(absolutePath)) {
+                continue;
+            }
+            fs_1.default.mkdirSync(path_1.default.dirname(absolutePath), { recursive: true });
+            fs_1.default.writeFileSync(absolutePath, content, 'utf8');
+        }
+    }
+    async ensureAgentFrontendPolish(message = '', context = {}) {
+        const rootPath = this.resolveAgentTargetPath(context);
+        if (!rootPath || !fs_1.default.existsSync(rootPath)) {
+            return;
+        }
+        const prompt = String(message || '');
+        const expectedFiles = this.extractExpectedWorkspaceFiles(message, context);
+        const looksLikeFrontendTask = /(premium|polished|landing|site|page|dashboard|saas|frontend|ui|pricing|showcase)/i.test(prompt)
+            || expectedFiles.some((filePath) => /\.(html|css|js)$/i.test(filePath));
+        if (!looksLikeFrontendTask) {
+            return;
+        }
+        const htmlPath = path_1.default.join(rootPath, 'index.html');
+        const cssPath = path_1.default.join(rootPath, 'styles.css');
+        if (!fs_1.default.existsSync(htmlPath) || !fs_1.default.existsSync(cssPath)) {
+            return;
+        }
+        const jsCandidates = ['app.js', 'script.js', 'main.js']
+            .map((fileName) => path_1.default.join(rootPath, fileName))
+            .filter((filePath) => fs_1.default.existsSync(filePath));
+        const jsPath = jsCandidates[0] || path_1.default.join(rootPath, 'app.js');
+        const html = fs_1.default.readFileSync(htmlPath, 'utf8');
+        let css = fs_1.default.readFileSync(cssPath, 'utf8');
+        let js = fs_1.default.existsSync(jsPath) ? fs_1.default.readFileSync(jsPath, 'utf8') : '';
+        let nextHtml = html;
+        const keyframesBlocks = Array.from(js.matchAll(/@keyframes[\s\S]*?\n\}/g)).map((match) => match[0]);
+        if (keyframesBlocks.length > 0) {
+            const migrated = keyframesBlocks.filter((block) => !css.includes(block));
+            if (migrated.length > 0) {
+                css = `${css.trimEnd()}\n\n/* Vigthoria CLI Recovered CSS */\n${migrated.join('\n\n')}\n`;
+            }
+            js = js.replace(/\n?@keyframes[\s\S]*?\n\}/g, '').trim();
+            fs_1.default.writeFileSync(cssPath, `${css.trimEnd()}\n`, 'utf8');
+            fs_1.default.writeFileSync(jsPath, js ? `${js.trimEnd()}\n` : '', 'utf8');
+        }
+        const wantsPricing = /(pay-as-you-go|pricing)/i.test(prompt);
+        if (wantsPricing && !/(id="pricing"|Pay-as-you-go|pay-as-you-go|pricing tiers)/i.test(nextHtml)) {
+            nextHtml = this.injectSectionBeforeFooter(nextHtml, `
+    <section id="pricing" class="module pricing">
+        <h2>Pay-as-you-go Pricing</h2>
+        <p>Start with the modules you need, scale usage by workload, and keep enterprise-grade visibility across teams.</p>
+        <div class="pricing-grid">
+            <article>
+                <h3>Builder</h3>
+                <p>Usage-based coding, workflow, and storage for product teams shipping fast.</p>
+            </article>
+            <article>
+                <h3>Studio</h3>
+                <p>Metered voice and music generation with predictable controls for creative operations.</p>
+            </article>
+            <article>
+                <h3>Scale</h3>
+                <p>Hosting, finance, and orchestration capacity that expands with customer demand.</p>
+            </article>
+        </div>
+    </section>`);
+            nextHtml = this.injectNavLink(nextHtml, 'pricing', 'Pricing');
+        }
+        const wantsTrust = /(trust|security|secure)/i.test(prompt);
+        if (wantsTrust && !/(id="trust"|id="security"|Trust and Security|Security)/i.test(nextHtml)) {
+            nextHtml = this.injectSectionBeforeFooter(nextHtml, `
+    <section id="trust" class="module trust">
+        <h2>Trust and Security</h2>
+        <p>Role-aware access, auditable workflows, and isolated infrastructure keep sensitive workloads controlled from prototype to production.</p>
+        <ul class="trust-list">
+            <li>Authenticated access across CLI, Code Fork, and hosted workspaces.</li>
+            <li>Scalable storage and hosting paths aligned with enterprise deployment requirements.</li>
+            <li>Operational visibility for pricing, usage, and automation governance.</li>
+        </ul>
+    </section>`);
+            nextHtml = this.injectNavLink(nextHtml, 'trust', 'Trust');
+        }
+        if (nextHtml !== html) {
+            fs_1.default.writeFileSync(htmlPath, `${nextHtml.trimEnd()}\n`, 'utf8');
+            nextHtml = fs_1.default.readFileSync(htmlPath, 'utf8');
+        }
+        if (/classList\.add\('hidden'\)|classList\.add\("hidden"\)|classList\.add\('revealed'\)|classList\.add\("revealed"\)/.test(js)
+            && !/\.hidden\b|\.revealed\b/.test(css)) {
+            css = `${css.trimEnd()}\n\n/* Vigthoria CLI Visibility States */\n.hidden {\n    opacity: 0;\n    transform: translateY(24px);\n}\n\n.revealed {\n    opacity: 1;\n    transform: translateY(0);\n    transition: opacity 0.7s ease, transform 0.7s ease;\n}\n`;
+            fs_1.default.writeFileSync(cssPath, `${css.trimEnd()}\n`, 'utf8');
+        }
+        const combined = `${nextHtml}\n${css}\n${js}`;
+        if (/IntersectionObserver|motion-reveal|\.revealed\b|vigCliFadeIn|classList\.add\('is-visible'\)|classList\.add\("is-visible"\)/i.test(combined)) {
+            return;
+        }
+        const cssMarker = '/* Vigthoria CLI Motion Enhancement */';
+        const jsMarker = '/* Vigthoria CLI Motion Enhancement */';
+        if (!css.includes(cssMarker)) {
+            fs_1.default.appendFileSync(cssPath, `\n\n${cssMarker}\n.hero, section {\n    opacity: 0;\n    transform: translateY(24px);\n    animation: vigCliFadeIn 0.8s ease forwards;\n}\n\nsection {\n    animation-delay: 0.12s;\n}\n\nbutton, .cta, a {\n    transition: transform 0.25s ease, opacity 0.25s ease;\n}\n\nbutton:hover, .cta:hover, a:hover {\n    transform: translateY(-2px);\n}\n\n.motion-reveal {\n    opacity: 0;\n    transform: translateY(24px);\n    transition: opacity 0.7s ease, transform 0.7s ease;\n}\n\n.motion-reveal.is-visible {\n    opacity: 1;\n    transform: translateY(0);\n}\n\n@keyframes vigCliFadeIn {\n    from {\n        opacity: 0;\n        transform: translateY(24px);\n    }\n    to {\n        opacity: 1;\n        transform: translateY(0);\n    }\n}\n`, 'utf8');
+        }
+        if (!js.includes(jsMarker)) {
+            fs_1.default.appendFileSync(jsPath, `\n\n${jsMarker}\ndocument.addEventListener('DOMContentLoaded', () => {\n    const revealTargets = document.querySelectorAll('section, .hero, .project-grid > *, .journal-preview > *');\n    if (typeof IntersectionObserver !== 'function') {\n        revealTargets.forEach((element) => element.classList.add('is-visible'));\n        return;\n    }\n\n    const observer = new IntersectionObserver((entries) => {\n        entries.forEach((entry) => {\n            if (entry.isIntersecting) {\n                entry.target.classList.add('is-visible');\n                observer.unobserve(entry.target);\n            }\n        });\n    }, { threshold: 0.16 });\n\n    revealTargets.forEach((element, index) => {\n        element.classList.add('motion-reveal');\n        element.style.transitionDelay = String(Math.min(index * 60, 320)) + 'ms';\n        observer.observe(element);\n    });\n});\n`, 'utf8');
+        }
+    }
+    injectSectionBeforeFooter(html, sectionMarkup) {
+        if (/<footer[\s>]/i.test(html)) {
+            return html.replace(/<footer/i, `${sectionMarkup}\n    <footer`);
+        }
+        if (/<\/body>/i.test(html)) {
+            return html.replace(/\s*<\/body>/i, `${sectionMarkup}\n</body>`);
+        }
+        return `${html.trimEnd()}\n${sectionMarkup}\n`;
+    }
+    injectNavLink(html, sectionId, label) {
+        if (new RegExp(`href=\"#${sectionId}\"`, 'i').test(html)) {
+            return html;
+        }
+        if (/<\/ul>/i.test(html)) {
+            return html.replace(/\s*<\/ul>/i, `\n            <li><a href="#${sectionId}">${label}</a></li>\n        </ul>`);
+        }
+        return html;
+    }
+    formatV3AgentResponse(data) {
+        const result = data?.result || {};
+        if (typeof result === 'string') {
+            return result;
+        }
+        if (typeof result?.summary === 'string' && result.summary.trim()) {
+            return result.summary;
+        }
+        if (typeof result?.message === 'string' && result.message.trim()) {
+            return result.message;
+        }
+        if (Array.isArray(data?.events)) {
+            const completionEvent = [...data.events].reverse().find((event) => event && event.type === 'complete' && typeof event.summary === 'string');
+            if (completionEvent) {
+                return completionEvent.summary;
+            }
+            const messageEvent = [...data.events].reverse().find((event) => event && event.type === 'message' && typeof event.content === 'string');
+            if (messageEvent) {
+                return messageEvent.content;
+            }
+        }
+        const text = JSON.stringify(data, null, 2);
+        return text.length > 12000 ? `${text.slice(0, 12000)}\n\n[V3 agent output truncated]` : text;
+    }
+    async collectV3AgentStream(response, context = {}) {
+        if (!response.body || typeof response.body.getReader !== 'function') {
+            return response.json();
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const events = [];
+        let final = null;
+        let contextId = response.headers.get('x-context-id') || String(context.contextId || '').trim() || null;
+        const streamedFiles = {};
+        const idleTimeoutMs = context.agentIdleTimeoutMs || DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
+        while (true) {
+            let chunk;
+            try {
+                const readPromise = reader.read();
+                while (true) {
+                    const timeoutSentinel = Symbol('v3-agent-idle-timeout');
+                    const result = idleTimeoutMs > 0
+                        ? await Promise.race([
+                            readPromise,
+                            new Promise((resolve) => {
+                                setTimeout(() => resolve(timeoutSentinel), idleTimeoutMs);
+                            }),
+                        ])
+                        : await readPromise;
+                    if (result !== timeoutSentinel) {
+                        chunk = result;
+                        break;
+                    }
+                    if (this.hasAgentWorkspaceOutput(context)) {
+                        const stalledError = new Error('V3 agent stream stalled after writing workspace output');
+                        stalledError.name = 'AbortError';
+                        stalledError.partialData = {
+                            task_id: events.find((event) => event && event.task_id)?.task_id || null,
+                            context_id: contextId,
+                            result: final,
+                            events,
+                            files: streamedFiles,
+                        };
+                        throw stalledError;
+                    }
+                }
+            }
+            catch (error) {
+                if (error && error.name === 'AbortError') {
+                    error.partialData = {
+                        task_id: events.find((event) => event && event.task_id)?.task_id || null,
+                        context_id: contextId,
+                        result: final,
+                        events,
+                        files: streamedFiles,
+                    };
+                }
+                throw error;
+            }
+            const { done, value } = chunk;
+            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 || payload === '[DONE]') {
+                    continue;
+                }
+                const event = JSON.parse(payload);
+                events.push(event);
+                if (!contextId && typeof event.context_id === 'string' && event.context_id.trim()) {
+                    contextId = event.context_id.trim();
+                }
+                this.captureV3AgentStreamMutation(event, streamedFiles);
+                if (typeof context.onStreamEvent === 'function') {
+                    try {
+                        context.onStreamEvent(event);
+                    }
+                    catch {
+                        // Ignore UI callback failures; never break the agent stream for them.
+                    }
+                }
+                if (event.type === 'error') {
+                    if (this.hasAgentWorkspaceOutput(context)) {
+                        return {
+                            task_id: events.find((entry) => entry && entry.task_id)?.task_id || null,
+                            context_id: contextId,
+                            result: final || event,
+                            events,
+                            files: streamedFiles,
+                            partial: true,
+                        };
+                    }
+                    throw new Error(event.message || 'V3 agent returned an error');
+                }
+                if (event.type === 'complete' || event.type === 'message') {
+                    final = event;
+                }
+            }
+        }
+        return {
+            task_id: events.find((event) => event && event.task_id)?.task_id || null,
+            context_id: contextId,
+            result: final,
+            events,
+            files: streamedFiles,
+        };
+    }
+    async runV3AgentWorkflow(message, context = {}) {
+        const executionContext = await this.bindExecutionContext(context);
+        const timeoutMs = executionContext.agentTimeoutMs || DEFAULT_V3_AGENT_TIMEOUT_MS;
+        const errors = [];
+        const expectedFiles = this.extractExpectedWorkspaceFiles(message, executionContext);
+        const requestBody = {
+            request: message,
+            context: this.buildV3AgentContext(executionContext),
+            context_id: executionContext.contextId,
+            mcp_context_id: executionContext.mcpContextId || null,
+            stream: true,
+        };
+        for (const baseUrl of this.getV3AgentBaseUrls()) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await this.executeV3AgentRunRequest(baseUrl, requestBody, executionContext, controller.signal);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => '');
+                    throw new Error(`V3 agent ${response.status}: ${errorText.slice(0, 200)}`);
+                }
+                const data = await this.collectV3AgentStream(response, executionContext);
+                const contextId = data.context_id || response.headers.get('x-context-id') || executionContext.contextId || null;
+                const mcpContextId = response.headers.get('x-mcp-context-id') || executionContext.mcpContextId || null;
+                this.recoverAgentWorkspaceFiles(executionContext, data.files || {}, expectedFiles);
+                await this.waitForAgentWorkspaceSettle(executionContext, { expectedFiles });
+                await this.ensureAgentFrontendPolish(message, executionContext);
+                const previewGate = await this.runTemplateServicePreviewGate(message, executionContext);
+                return {
+                    content: this.formatV3AgentResponse(data),
+                    taskId: data.task_id || null,
+                    contextId,
+                    backendUrl: baseUrl,
+                    metadata: { source: 'v3-agent', mode: 'agent', contextId, mcpContextId, previewGate },
+                };
+            }
+            catch (error) {
+                if (error && error.name === 'AbortError' && error.partialData && this.hasAgentWorkspaceOutput(executionContext)) {
+                    this.recoverAgentWorkspaceFiles(executionContext, error.partialData.files || {}, expectedFiles);
+                    await this.waitForAgentWorkspaceSettle(executionContext, { expectedFiles });
+                    await this.ensureAgentFrontendPolish(message, executionContext);
+                    const previewGate = await this.runTemplateServicePreviewGate(message, executionContext);
+                    return {
+                        content: this.formatV3AgentResponse(error.partialData) || 'V3 agent wrote workspace files before the request timed out waiting for a final summary.',
+                        taskId: error.partialData.task_id || null,
+                        contextId: error.partialData.context_id || executionContext.contextId || null,
+                        backendUrl: baseUrl,
+                        partial: true,
+                        metadata: { source: 'v3-agent', mode: 'agent', partial: true, contextId: error.partialData.context_id || executionContext.contextId || null, mcpContextId: executionContext.mcpContextId || null, previewGate },
+                    };
+                }
+                errors.push(`${baseUrl}: ${error?.message || String(error)}`);
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        const onlyUnauthorizedErrors = errors.length > 0 && errors.every((entry) => /V3 agent 401:/i.test(entry));
+        const usingStoredConfigToken = !process.env.VIGTHORIA_TOKEN
+            && !process.env.VIGTHORIA_AUTH_TOKEN
+            && Boolean(this.config.get('authToken'));
+        if (onlyUnauthorizedErrors && usingStoredConfigToken) {
+            this.config.clearAuth();
+            throw new Error('V3 agent authentication failed. The stored CLI login token is invalid or expired. Run vigthoria login again.');
+        }
+        throw new Error(errors.join(' | '));
+    }
+    formatOperatorResponse(data = {}) {
+        const lines = [];
+        if (data.summary) {
+            lines.push(String(data.summary).trim());
+        }
+        if (Array.isArray(data.completed_agents) && data.completed_agents.length > 0) {
+            lines.push(`Completed agents: ${data.completed_agents.join(', ')}`);
+        }
+        if (data.details) {
+            const detailText = JSON.stringify(data.details, null, 2);
+            if (detailText && detailText !== '{}') {
+                lines.push(detailText.length > 12000 ? `${detailText.slice(0, 12000)}\n\n[Operator output truncated]` : detailText);
+            }
+        }
+        return lines.filter(Boolean).join('\n\n').trim() || 'Operator workflow completed.';
+    }
+    async runOperatorWorkflow(message, context = {}) {
+        const executionContext = await this.bindExecutionContext(context);
+        const timeoutMs = context.operatorTimeoutMs || DEFAULT_OPERATOR_TIMEOUT_MS;
+        const errors = [];
+        const authToken = this.config.get('authToken');
+        for (const baseUrl of this.getOperatorBaseUrls()) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(this.getOperatorStreamUrl(baseUrl), {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'text/event-stream',
+                        ...(executionContext.mcpContextId ? { 'X-MCP-Context-Id': String(executionContext.mcpContextId) } : {}),
+                        ...(authToken ? {
+                            Authorization: `Bearer ${authToken}`,
+                            Cookie: `vigthoria-auth-token=${authToken}`,
+                        } : {}),
+                    },
+                    body: JSON.stringify({
+                        prompt: message,
+                        task: message,
+                        raw_prompt: executionContext.rawPrompt || null,
+                        context_id: executionContext.contextId,
+                        trace_id: executionContext.traceId,
+                        mcp_context_id: executionContext.mcpContextId || null,
+                        context: {
+                            workspace: { path: executionContext.workspacePath || executionContext.projectPath || executionContext.targetPath || process.cwd() },
+                            workspace_path: executionContext.workspacePath || executionContext.projectPath || executionContext.targetPath || process.cwd(),
+                            model: this.resolveModelId(executionContext.model || 'code-8b'),
+                            history: executionContext.history || [],
+                            executionSurface: executionContext.executionSurface || 'cli',
+                            clientSurface: executionContext.clientSurface || 'cli',
+                            contextId: executionContext.contextId,
+                            traceId: executionContext.traceId,
+                            mcpContextId: executionContext.mcpContextId || null,
+                            mcp_context_id: executionContext.mcpContextId || null,
+                            rawPrompt: executionContext.rawPrompt || null,
+                            requestStartedAt: executionContext.requestStartedAt,
+                        },
+                        workflow_type: executionContext.workflowType || 'analysis_only',
+                        options: {
+                            stream: true,
+                            save_to_vigflow: executionContext.savePlanToVigFlow === true,
+                        },
+                    }),
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => '');
+                    throw new Error(`Operator stream ${response.status}: ${errorText.slice(0, 200)}`);
+                }
+                if (!response.body || typeof response.body.getReader !== 'function') {
+                    const fallbackData = await response.json();
+                    return {
+                        content: this.formatOperatorResponse(fallbackData),
+                        workflowId: fallbackData.workflow_id || null,
+                        contextId: fallbackData.context_id || response.headers.get('x-context-id') || executionContext.contextId || null,
+                        backendUrl: baseUrl,
+                        savedWorkflow: fallbackData.saved_workflow || null,
+                        metadata: {
+                            source: 'operator',
+                            mode: 'operator',
+                            contextId: fallbackData.context_id || response.headers.get('x-context-id') || executionContext.contextId || null,
+                            mcpContextId: fallbackData.mcp_context_id || response.headers.get('x-mcp-context-id') || executionContext.mcpContextId || null,
+                        },
+                    };
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                let workflowId = null;
+                let contextId = response.headers.get('x-context-id') || executionContext.contextId || null;
+                let mcpContextId = response.headers.get('x-mcp-context-id') || executionContext.mcpContextId || null;
+                let resultPayload = null;
+                let savedWorkflow = null;
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    buffer += decoder.decode(value, { stream: true });
+                    const chunks = buffer.split('\n\n');
+                    buffer = chunks.pop() || '';
+                    for (const chunk of chunks) {
+                        const lines = chunk.split('\n');
+                        let eventName = 'message';
+                        const dataLines = [];
+                        for (const line of lines) {
+                            if (line.startsWith('event:')) {
+                                eventName = line.slice(6).trim();
+                            }
+                            else if (line.startsWith('data:')) {
+                                dataLines.push(line.slice(5).trim());
+                            }
+                        }
+                        if (dataLines.length === 0) {
+                            continue;
+                        }
+                        let payload = null;
+                        try {
+                            payload = JSON.parse(dataLines.join('\n'));
+                        }
+                        catch {
+                            payload = { raw: dataLines.join('\n') };
+                        }
+                        if (payload.workflow_id && !workflowId) {
+                            workflowId = payload.workflow_id;
+                        }
+                        if (!contextId && typeof payload.context_id === 'string' && payload.context_id.trim()) {
+                            contextId = payload.context_id.trim();
+                        }
+                        if (!mcpContextId && typeof payload.mcp_context_id === 'string' && payload.mcp_context_id.trim()) {
+                            mcpContextId = payload.mcp_context_id.trim();
+                        }
+                        if (!savedWorkflow && payload.saved_workflow && typeof payload.saved_workflow === 'object') {
+                            savedWorkflow = payload.saved_workflow;
+                        }
+                        if (typeof context.onStreamEvent === 'function') {
+                            try {
+                                context.onStreamEvent({ type: eventName, ...payload, context_id: payload.context_id || contextId, mcp_context_id: payload.mcp_context_id || mcpContextId });
+                            }
+                            catch {
+                                // UI callback failures must not break operator execution.
+                            }
+                        }
+                        if (eventName === 'result') {
+                            resultPayload = payload;
+                        }
+                        if (eventName === 'error') {
+                            throw new Error(payload.error || payload.message || 'Operator workflow failed');
+                        }
+                    }
+                }
+                return {
+                    content: this.formatOperatorResponse(resultPayload || {}),
+                    workflowId,
+                    contextId,
+                    backendUrl: baseUrl,
+                    savedWorkflow,
+                    metadata: { source: 'operator', mode: 'operator', contextId, mcpContextId, savedWorkflowId: savedWorkflow?.id || null },
+                };
+            }
+            catch (error) {
+                errors.push(`${baseUrl}: ${error?.message || String(error)}`);
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        throw new Error(errors.join(' | '));
+    }
     /**
      * Chat API - Direct Vigthoria Models API Architecture
      *
@@ -199,7 +1653,9 @@ class APIClient {
      */
     async chat(messages, model, useLocal = false) {
         const resolvedModel = this.resolveModelId(model);
-        const candidateModels = [resolvedModel];
+        const candidateModels = this.isCloudModelId(resolvedModel) && !this.canUseCloudModel()
+            ? [this.getSelfHostedFallbackModelId(resolvedModel, model)]
+            : [resolvedModel];
         const fallbackModel = this.getFallbackModelId(resolvedModel);
         if (fallbackModel && fallbackModel !== resolvedModel) {
             candidateModels.push(fallbackModel);
@@ -216,6 +1672,9 @@ class APIClient {
         // No more localhost fallbacks - CLI is for external users!
         throw new Error('AI service unavailable. Please check your internet connection or try again later.');
     }
+    shouldSkipCloudRoutes(resolvedModel) {
+        return this.shouldSimulateCloudFailure() && this.isCloudModelId(resolvedModel);
+    }
     async tryChatWithModel(messages, resolvedModel, requestedModel) {
         const preferSelfHostedFirst = this.isSelfHostedPreferredModel(resolvedModel, requestedModel);
         if (preferSelfHostedFirst) {
@@ -225,7 +1684,7 @@ class APIClient {
             }
         }
         // STRATEGY 1: Direct Vigthoria Models API (api.vigthoria.io)
-        if (!this.shouldSimulateCloudFailure()) {
+        if (!this.shouldSkipCloudRoutes(resolvedModel)) {
             try {
                 this.logger.debug(`Direct Vigthoria Models API: ${resolvedModel}`);
                 const token = this.config.get('authToken');
@@ -260,10 +1719,10 @@ class APIClient {
             }
         }
         else {
-            this.logger.debug(`Simulating cloud failure for ${resolvedModel}; skipping public API route.`);
+            this.logger.debug(`Simulating cloud failure for ${resolvedModel}; skipping cloud-backed public API route.`);
         }
         // STRATEGY 2: Vigthoria Cloud API via Coder (authenticated users only)
-        if (this.config.isAuthenticated() && !this.shouldSimulateCloudFailure()) {
+        if (this.config.isAuthenticated() && !this.shouldSkipCloudRoutes(resolvedModel)) {
             try {
                 this.logger.debug(`Vigthoria Cloud API fallback: ${resolvedModel}`);
                 const response = await this.client.post('/api/ai/chat', {
@@ -302,7 +1761,7 @@ class APIClient {
         return null;
     }
     async trySelfHostedChatWithModel(messages, resolvedModel, requestedModel) {
-        if (!this.shouldTrySelfHostedFallback(resolvedModel, requestedModel)) {
+        if (!this.selfHostedModelRouterClient || !this.shouldTrySelfHostedFallback(resolvedModel, requestedModel)) {
             return null;
         }
         const selfHostedModel = this.getSelfHostedFallbackModelId(resolvedModel, requestedModel);
@@ -344,16 +1803,41 @@ class APIClient {
         const cloudModels = new Set([
             'deepseek-v3.1:671b-cloud',
             'moonshotai/kimi-k2.5',
+            'vigthoria-cloud-pro',
+            'vigthoria-cloud-k2',
+            'vigthoria-cloud-ultra',
         ]);
         if (cloudModels.has(resolvedModel)) {
             return 'vigthoria-v3-code-30b';
         }
         return null;
     }
+    isCloudModelId(resolvedModel) {
+        return resolvedModel === 'deepseek-v3.1:671b-cloud'
+            || resolvedModel === 'moonshotai/kimi-k2.5'
+            || resolvedModel === 'vigthoria-cloud-pro'
+            || resolvedModel === 'vigthoria-cloud-k2'
+            || resolvedModel === 'vigthoria-cloud-ultra';
+    }
+    canUseCloudModel() {
+        return this.config.hasCloudAccess();
+    }
+    resolvePermittedModelId(shortName) {
+        const resolvedModel = this.resolveModelId(shortName);
+        if (this.isCloudModelId(resolvedModel) && !this.canUseCloudModel()) {
+            const fallbackModel = this.getSelfHostedFallbackModelId(resolvedModel, shortName);
+            this.logger.debug(`Blocked unauthorized cloud model ${shortName}; using fallback ${fallbackModel}`);
+            return fallbackModel;
+        }
+        return resolvedModel;
+    }
     shouldSimulateCloudFailure() {
         return process.env.VIGTHORIA_SIMULATE_CLOUD_FAILURE === '1';
     }
     shouldTrySelfHostedFallback(resolvedModel, requestedModel) {
+        if (!this.selfHostedModelRouterClient) {
+            return false;
+        }
         const normalizedRequested = String(requestedModel || '').toLowerCase();
         return this.isSelfHostedPreferredModel(resolvedModel, requestedModel)
             || normalizedRequested === 'cloud'
@@ -392,7 +1876,7 @@ class APIClient {
                 ws.send(JSON.stringify({
                     type: 'chat',
                     messages,
-                    model: this.resolveModelId(model),
+                    model: this.resolvePermittedModelId(model),
                     stream: true,
                 }));
             });
@@ -421,7 +1905,7 @@ class APIClient {
                 ws.send(JSON.stringify({
                     type: 'chat',
                     messages,
-                    model: this.resolveModelId(model),
+                    model: this.resolvePermittedModelId(model),
                     stream: true,
                 }));
             });
@@ -461,7 +1945,7 @@ class APIClient {
         const response = await this.client.post('/api/ai/generate', {
             prompt,
             language,
-            model: this.resolveModelId(model),
+            model: this.resolvePermittedModelId(model),
         });
         return response.data.code;
     }
@@ -470,7 +1954,7 @@ class APIClient {
         const response = await this.client.post('/api/ai/generate-project', {
             prompt,
             projectType,
-            model: this.resolveModelId(model),
+            model: this.resolvePermittedModelId(model),
         }, {
             timeout: 300000, // 5 minutes for complex generation
         });
@@ -510,7 +1994,7 @@ class APIClient {
             // VIGTHORIA LOCAL - Self-hosted models
             // ═══════════════════════════════════════════════════════════════
             'fast': 'vigthoria-fast-1.7b',
-            'mini': 'vigthoria-fast-1.7b',
+            'mini': 'vigthoria-mini-0.6b',
             'balanced': 'vigthoria-balanced-4b',
             'creative': 'vigthoria-creative-9b-v4',
             // Code Models - 30B is the default powerhouse
@@ -522,9 +2006,9 @@ class APIClient {
             // ═══════════════════════════════════════════════════════════════
             // VIGTHORIA CLOUD - Premium cloud models (internal routing)
             // ═══════════════════════════════════════════════════════════════
-            'cloud': 'deepseek-v3.1:671b-cloud',
-            'cloud-reason': 'moonshotai/kimi-k2.5',
-            'ultra': 'deepseek-v3.1:671b-cloud',
+            'cloud': 'vigthoria-cloud-pro',
+            'cloud-reason': 'vigthoria-cloud-k2',
+            'ultra': 'vigthoria-cloud-ultra',
         };
         // If already a full model ID, return as-is
         if (shortName.includes('vigthoria') || shortName.includes('/') || shortName.includes(':')) {
@@ -533,18 +2017,276 @@ class APIClient {
             }
             return shortName;
         }
-        return modelMap[shortName] || 'qwen3-coder:latest'; // Default to 30B
+        return modelMap[shortName] || 'vigthoria-v3-code-30b';
     }
-    // Health check
-    async healthCheck() {
+    async getCoderHealth() {
         try {
             const response = await this.client.get('/api/health', { timeout: 10000 });
-            return response.data?.status === 'ok' || response.data?.healthy === true;
+            const ok = response.data?.status === 'ok' || response.data?.healthy === true;
+            return {
+                name: 'Coder API',
+                endpoint: `${this.config.get('apiUrl')}/api/health`,
+                ok,
+                details: { health: response.data },
+            };
         }
-        catch {
-            return false;
+        catch (error) {
+            return {
+                name: 'Coder API',
+                endpoint: `${this.config.get('apiUrl')}/api/health`,
+                ok: false,
+                error: error.message,
+            };
         }
     }
+    async getModelsHealth() {
+        const modelsApiUrl = this.config.get('modelsApiUrl');
+        try {
+            const [healthResponse, modelsResponse] = await Promise.all([
+                this.modelRouterClient.get('/health', { timeout: 10000 }),
+                this.modelRouterClient.get('/v1/models', { timeout: 15000 }),
+            ]);
+            const healthOk = healthResponse.data?.status === 'healthy'
+                || healthResponse.data?.status === 'ok'
+                || healthResponse.data?.healthy === true;
+            const modelCount = Array.isArray(modelsResponse.data?.data) ? modelsResponse.data.data.length : 0;
+            return {
+                name: 'Models API',
+                endpoint: `${modelsApiUrl}/health`,
+                ok: healthOk && modelCount > 0,
+                details: {
+                    health: healthResponse.data,
+                    modelCount,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                name: 'Models API',
+                endpoint: `${modelsApiUrl}/health`,
+                ok: false,
+                error: error.message,
+            };
+        }
+    }
+    async getSelfHostedHealth() {
+        const selfHostedModelsApiUrl = this.getSelfHostedModelsApiUrl();
+        if (!selfHostedModelsApiUrl || !this.selfHostedModelRouterClient) {
+            return null;
+        }
+        try {
+            const response = await this.selfHostedModelRouterClient.get('/health', { timeout: 10000 });
+            const ok = response.data?.status === 'healthy'
+                || response.data?.status === 'ok'
+                || response.data?.healthy === true;
+            return {
+                name: 'Self-hosted Models API',
+                endpoint: `${selfHostedModelsApiUrl}/health`,
+                ok,
+                details: { health: response.data },
+            };
+        }
+        catch (error) {
+            return {
+                name: 'Self-hosted Models API',
+                endpoint: `${selfHostedModelsApiUrl}/health`,
+                ok: false,
+                error: error.message,
+            };
+        }
+    }
+    async getV3AgentHealth() {
+        const endpoint = this.getV3AgentRunUrl(this.getV3AgentBaseUrls()[0]).replace('/api/agent/run', '/health');
+        try {
+            const response = await fetch(endpoint, {
+                method: 'GET',
+                headers: await this.getV3AgentHeaders(),
+            });
+            if (!response.ok) {
+                throw new Error(`V3 health ${response.status}`);
+            }
+            const data = await response.json();
+            const ok = data?.status === 'ok' || data?.healthy === true;
+            return {
+                name: 'V3 Agent',
+                endpoint,
+                ok,
+                details: { health: data },
+            };
+        }
+        catch (error) {
+            return {
+                name: 'V3 Agent',
+                endpoint,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async getHyperLoopHealth() {
+        const endpoint = process.env.VIGTHORIA_HYPERLOOP_URL || 'http://127.0.0.1:8020/api/hyperloop/health';
+        try {
+            const token = this.getAccessToken();
+            const response = await fetch(endpoint, {
+                method: 'GET',
+                headers: token ? { Authorization: `Bearer ${token}` } : undefined,
+            });
+            if (!response.ok) {
+                throw new Error(`Hyper Loop health ${response.status}`);
+            }
+            const data = await response.json();
+            const ok = data?.status === 'healthy' || data?.status === 'ok' || data?.healthy === true;
+            return {
+                name: 'Hyper Loop',
+                endpoint,
+                ok,
+                details: { health: data },
+            };
+        }
+        catch (error) {
+            return {
+                name: 'Hyper Loop',
+                endpoint,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async getRepoMemoryHealth(context = {}) {
+        const endpoint = process.env.VIGTHORIA_HYPERLOOP_EXECUTE_URL || 'http://127.0.0.1:8020/api/hyperloop/execute';
+        const modulesEndpoint = process.env.VIGTHORIA_HYPERLOOP_MODULES_URL || 'http://127.0.0.1:8020/api/hyperloop/modules';
+        const token = this.getAccessToken();
+        const projectPath = this.resolveAgentTargetPath(context);
+        try {
+            const modulesResponse = await fetch(modulesEndpoint, {
+                method: 'GET',
+                headers: {
+                    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                },
+            });
+            if (!modulesResponse.ok) {
+                throw new Error(`Repo memory modules ${modulesResponse.status}`);
+            }
+            const modulesData = await modulesResponse.json();
+            const modules = Array.isArray(modulesData?.modules) ? modulesData.modules : [];
+            const compactor = modules.find((entry) => entry && entry.name === 'repo_context_compactor');
+            let compactContextLength = 0;
+            try {
+                const probeResponse = await fetch(endpoint, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                    },
+                    body: JSON.stringify({
+                        module: 'repo_context_compactor',
+                        payload: {
+                            path: projectPath,
+                            request_focus: 'Capability truth status probe',
+                            max_files: 20,
+                            max_chars: 800,
+                        },
+                        context: {
+                            project_path: projectPath,
+                            source: 'vigthoria-cli-capability-truth',
+                        },
+                    }),
+                });
+                if (probeResponse.ok) {
+                    const probeData = await probeResponse.json();
+                    compactContextLength = String(probeData?.result?.compact_context || '').length;
+                }
+            }
+            catch {
+                // Availability is determined by the module registry; direct compactor output is supplemental only.
+            }
+            const ok = Boolean(compactor && compactor.initialized !== false);
+            return {
+                name: 'Repo Memory',
+                endpoint: modulesEndpoint,
+                ok,
+                details: {
+                    projectPath,
+                    compactContextLength,
+                    moduleRegistered: Boolean(compactor),
+                },
+                ...(ok ? {} : { error: 'repo_context_compactor is not registered in Hyper Loop' }),
+            };
+        }
+        catch (error) {
+            return {
+                name: 'Repo Memory',
+                endpoint: modulesEndpoint,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async getDevtoolsBridgeStatus() {
+        const host = process.env.VIGTHORIA_DEVTOOLS_BRIDGE_HOST || '127.0.0.1';
+        const port = Number.parseInt(process.env.VIGTHORIA_DEVTOOLS_BRIDGE_PORT || '4016', 10);
+        const endpoint = `ws://${host}:${port}/ws`;
+        return new Promise((resolve) => {
+            const socket = net_1.default.connect({ host, port, timeout: 1500 }, () => {
+                socket.end();
+                resolve({
+                    name: 'DevTools Bridge',
+                    endpoint,
+                    ok: true,
+                    details: { host, port },
+                });
+            });
+            socket.on('timeout', () => {
+                socket.destroy();
+                resolve({
+                    name: 'DevTools Bridge',
+                    endpoint,
+                    ok: false,
+                    error: 'Connection timed out',
+                });
+            });
+            socket.on('error', (error) => {
+                resolve({
+                    name: 'DevTools Bridge',
+                    endpoint,
+                    ok: false,
+                    error: error.message,
+                });
+            });
+        });
+    }
+    async getCapabilityTruthStatus(context = {}) {
+        const [v3Agent, hyperLoop, repoMemory, devtoolsBridge] = await Promise.all([
+            this.getV3AgentHealth(),
+            this.getHyperLoopHealth(),
+            this.getRepoMemoryHealth(context),
+            this.getDevtoolsBridgeStatus(),
+        ]);
+        return {
+            overallOk: v3Agent.ok && hyperLoop.ok && repoMemory.ok,
+            v3Agent,
+            hyperLoop,
+            repoMemory,
+            devtoolsBridge,
+        };
+    }
+    async getHealthStatus() {
+        const [coder, models, selfHosted] = await Promise.all([
+            this.getCoderHealth(),
+            this.getModelsHealth(),
+            this.getSelfHostedHealth(),
+        ]);
+        return {
+            overallOk: coder.ok && models.ok,
+            coder,
+            models,
+            selfHosted,
+        };
+    }
+    // Health check
+    async healthCheck() {
+        const status = await this.getHealthStatus();
+        return status.overallOk;
+    }
 }
 exports.APIClient = APIClient;
-//# sourceMappingURL=api.js.map