vigthoria-cli 1.11.19 → 1.11.27

package/dist/commands/chat.d.ts

@@ -52,6 +52,7 @@ export declare class ChatCommand {
     private v3StreamedAnswerDisplayed;
     private v3SeenToolCalls;
     private v3SeenToolResults;
+    private v3StartSeen;
     private lastAgentRoute;
     private lastAgentRunOutcome;
     private isJwtExpirationError;

package/dist/commands/chat.js

@@ -23,26 +23,23 @@ import { runTemplateInstantPath } from '../utils/templateInstantPath.js';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
-        return 300000;
+        return 0;
     }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
 const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS;
     if (!rawValue) {
-        return 90000;
+        return 0;
     }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
 const DEFAULT_V3_AGENT_SOFT_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_AGENT_SOFT_TIMEOUT_MS || process.env.V3_AGENT_SOFT_TIMEOUT_MS;
-    if (!rawValue) {
-        return 180000;
-    }
+    const rawValue = process.env.VIGTHORIA_AGENT_SOFT_TIMEOUT_MS || process.env.V3_AGENT_SOFT_TIMEOUT_MS || '300000';
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 180000;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
 })();
 export class ChatCommand {
     config;
@@ -77,6 +74,7 @@ export class ChatCommand {
     v3StreamedAnswerDisplayed = false;
     v3SeenToolCalls = new Set();
     v3SeenToolResults = new Set();
+    v3StartSeen = false;
     lastAgentRoute = null;
     // Last completed Agent run — used by /retry, /continue, and the final summary block.
     lastAgentRunOutcome = null;
@@ -299,7 +297,7 @@ export class ChatCommand {
     resolveAgentExecutionPolicy(prompt) {
         const explicitModel = this.modelExplicitlySelected;
         const heavyTask = this.config.isComplexTask(prompt);
-        const cloudEligible = this.config.hasCloudAccess() && this.hasOperatorAccess();
+        const cloudEligible = this.config.hasCloudAccess();
         const requiresV3Workflow = this.shouldRequireV3AgentWorkflow(prompt);
         if (explicitModel) {
             return {
@@ -1282,8 +1280,11 @@ export class ChatCommand {
             return;
         }
         if (event.type === 'start') {
-            this.v3IterationCount = 0;
-            this.v3ToolCallCount = 0;
+            if (this.v3StartSeen) {
+                spinner.text = 'Working...';
+                return;
+            }
+            this.v3StartSeen = true;
             if (spinner.isSpinning)
                 spinner.stop();
             process.stderr.write(chalk.cyan('  [Start] ') + 'Agent initialized\n');
@@ -2793,6 +2794,7 @@ export class ChatCommand {
             console.log(chalk.gray('━━━ ROUTING DECISION ━━━'));
             console.log(chalk.gray(`Reason: ${routingPolicy.routeReason}`));
             console.log(chalk.gray(`Model: ${routingPolicy.selectedModel}`));
+            console.log(chalk.gray('Remote Engine Session: true'));
             console.log(chalk.gray(`Cloud Eligible: ${routingPolicy.cloudEligible}`));
             console.log(chalk.gray(`Cloud Selected: ${routingPolicy.cloudSelected}`));
             if (routingPolicy.heavyTask) {
@@ -2808,6 +2810,7 @@ export class ChatCommand {
         this.v3StreamingStarted = false;
         this.v3StreamedAnswerBuffer = '';
         this.v3StreamedAnswerDisplayed = false;
+        this.v3StartSeen = false;
         this.v3SeenToolCalls.clear();
         this.v3SeenToolResults.clear();
         emitDeckEvent({ type: 'agent_start' });
@@ -3363,6 +3366,7 @@ export class ChatCommand {
         this.v3ToolCallCount = 0;
         this.v3LastActivity = Date.now();
         this.v3StreamingStarted = false;
+        this.v3StartSeen = false;
         try {
             const retryTaskType = this.inferAgentTaskType(rawPrompt);
             const retryResponse = await this.api.runV3AgentWorkflow(executionPrompt, {

package/dist/commands/index.js

@@ -11,6 +11,7 @@ import { GenerateCommand } from './generate.js';
 import { HistoryCommand } from './history.js';
 import { HubCommand } from './hub.js';
 import { LegionCommand } from './legion.js';
+import { MusicCommand } from './music.js';
 import { PreviewCommand } from './preview.js';
 import { ReplayCommand } from './replay.js';
 import { RepoCommand } from './repo.js';
@@ -96,6 +97,11 @@ const commandRegistry = [
         name: 'hub',
         handler: createClassRegistrar(HubCommand),
     },
+    {
+        name: 'music',
+        aliases: ['audio'],
+        handler: createClassRegistrar(MusicCommand),
+    },
     {
         name: 'repo',
         handler: createClassRegistrar(RepoCommand),

package/dist/commands/music.d.ts

@@ -0,0 +1,31 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+type MusicGenerateOptions = {
+    prompt?: string;
+    lyrics?: string;
+    duration?: string | number;
+    genre?: string;
+    language?: string;
+    voiceType?: string;
+    styleTags?: string;
+    voice?: string;
+    wait?: boolean;
+    pollInterval?: string | number;
+    json?: boolean;
+};
+type MusicStatusOptions = {
+    json?: boolean;
+};
+export declare class MusicCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private apiBase;
+    private authHeaders;
+    private request;
+    private uploadVoiceReference;
+    generate(promptArg: string | undefined, options: MusicGenerateOptions): Promise<void>;
+    status(taskId: string, options?: MusicStatusOptions): Promise<void>;
+    private waitForStatus;
+}
+export {};

package/dist/commands/music.js

@@ -0,0 +1,137 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+export class MusicCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    apiBase() {
+        const configured = String(this.config.getAll().musicApiUrl || '').trim();
+        return (process.env.VIGTHORIA_MUSIC_API_URL || configured || 'https://music.vigthoria.io').replace(/\/+$/, '');
+    }
+    authHeaders() {
+        const token = this.config.get('authToken');
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    }
+    async request(endpoint, init = {}) {
+        const response = await fetch(`${this.apiBase()}${endpoint}`, {
+            ...init,
+            headers: {
+                ...this.authHeaders(),
+                ...init.headers,
+            },
+        });
+        const text = await response.text();
+        let data = {};
+        try {
+            data = text ? JSON.parse(text) : {};
+        }
+        catch {
+            data = { message: text };
+        }
+        if (!response.ok) {
+            throw new Error(String(data.error || data.message || `Music API request failed: ${response.status}`));
+        }
+        return data;
+    }
+    async uploadVoiceReference(filePath) {
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath) || !fs.statSync(absolutePath).isFile()) {
+            throw new Error(`Voice reference file not found: ${filePath}`);
+        }
+        const form = new FormData();
+        const blob = new Blob([fs.readFileSync(absolutePath)]);
+        form.append('audio', blob, path.basename(absolutePath));
+        const data = await this.request('/api/voice/upload', {
+            method: 'POST',
+            body: form,
+        });
+        const referencePath = String(data.reference_audio_path || data.path || data.file_path || '').trim();
+        if (!referencePath) {
+            throw new Error('Voice upload succeeded but did not return a reference_audio_path.');
+        }
+        return referencePath;
+    }
+    async generate(promptArg, options) {
+        const prompt = String(promptArg || options.prompt || '').trim();
+        if (!prompt) {
+            throw new Error('Music generation requires a prompt.');
+        }
+        let referenceAudioPath = '';
+        if (options.voice) {
+            referenceAudioPath = await this.uploadVoiceReference(options.voice);
+        }
+        const duration = Math.max(1, Number(options.duration || 120));
+        const payload = {
+            prompt,
+            language: options.language || 'en',
+            voice_type: options.voiceType || 'female',
+            genre: options.genre || 'pop',
+            style_tags: options.styleTags || '',
+            lyrics: options.lyrics || undefined,
+            duration,
+            engine: 'v4',
+            is_preview: false,
+        };
+        if (referenceAudioPath) {
+            payload.voice_cloning = {
+                enabled: true,
+                reference_audio_path: referenceAudioPath,
+            };
+        }
+        const data = await this.request('/api/quick/generate', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        const taskId = String(data.task_id || data.session_id || '').trim();
+        if (options.json) {
+            console.log(JSON.stringify({ ...data, task_id: taskId || data.task_id }, null, 2));
+        }
+        else {
+            console.log(chalk.green('Music generation queued.'));
+            console.log(chalk.cyan('Task ID: ') + (taskId || '(pending)'));
+            if (data.queue_position)
+                console.log(chalk.gray(`Queue position: ${data.queue_position}`));
+            if (data.estimated_wait_seconds)
+                console.log(chalk.gray(`Estimated wait: ${data.estimated_wait_seconds}s`));
+        }
+        if (options.wait && taskId) {
+            await this.waitForStatus(taskId, Number(options.pollInterval || 5), Boolean(options.json));
+        }
+    }
+    async status(taskId, options = {}) {
+        const data = await this.request(`/api/status/${encodeURIComponent(taskId)}`);
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        console.log(chalk.cyan(`Music task ${taskId}`));
+        console.log(`Status: ${data.status || 'unknown'}`);
+        if (data.progress !== undefined)
+            console.log(`Progress: ${data.progress}%`);
+        const downloadUrl = data.download_url || data.audio_url || data.file_url || data.result_url;
+        if (downloadUrl)
+            console.log(`Download: ${downloadUrl}`);
+    }
+    async waitForStatus(taskId, intervalSeconds, json) {
+        const delay = Math.max(1, intervalSeconds) * 1000;
+        for (;;) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            const data = await this.request(`/api/status/${encodeURIComponent(taskId)}`);
+            const status = String(data.status || '').toLowerCase();
+            if (!json) {
+                const progress = data.progress !== undefined ? ` (${data.progress}%)` : '';
+                console.log(chalk.gray(`Status: ${status || 'unknown'}${progress}`));
+            }
+            if (['completed', 'complete', 'finished', 'failed', 'error', 'cancelled'].includes(status)) {
+                if (json)
+                    console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+        }
+    }
+}

package/dist/index.js

@@ -24,6 +24,7 @@ import { handleLogin, handleLogout, statusAction } from './commands/auth.js';
 import { ConfigCommand } from './commands/config.js';
 import { ReviewCommand } from './commands/review.js';
 import { HubCommand } from './commands/hub.js';
+import { MusicCommand } from './commands/music.js';
 import { RepoCommand } from './commands/repo.js';
 import { DeployCommand } from './commands/deploy.js';
 import { BridgeCommand } from './commands/bridge.js';
@@ -207,7 +208,7 @@ async function fetchNpmLatestVersion() {
     }
 }
 const VERSION = getVersion();
-const VIGTHORIA_DEFAULT_MANIFEST_URL = process.env.VIGTHORIA_UPDATE_MANIFEST_URL || "https://coder.vigthoria.io/releases/manifest.json";
+const VIGTHORIA_DEFAULT_MANIFEST_URL = process.env.VIGTHORIA_UPDATE_MANIFEST_URL || "https://extension.vigthoria.io/downloads/manifest.json";
 function resolveManifestEntry(manifest, channel) {
     const normalized = String(channel || 'stable').trim() || 'stable';
     if (manifest.channels && manifest.channels[normalized]) {
@@ -1043,6 +1044,36 @@ export async function main(args) {
         const hub = new HubCommand(config, logger);
         await hub.discover();
     });
+    const musicCommand = program
+        .command('music')
+        .alias('audio')
+        .description('Generate songs with Vigthoria Music AI / ACE-Step');
+    musicCommand
+        .command('generate [prompt]')
+        .alias('g')
+        .description('Queue full-song generation and return a task id')
+        .option('--lyrics <text>', 'Provide fixed lyrics instead of auto-writing lyrics')
+        .option('--duration <seconds>', 'Song duration in seconds', '120')
+        .option('--genre <genre>', 'Music genre', 'pop')
+        .option('--language <code>', 'Vocal language', 'en')
+        .option('--voice-type <type>', 'Voice type (female, male, mixed)', 'female')
+        .option('--style-tags <tags>', 'Additional style tags')
+        .option('--voice <path>', 'Upload a local voice reference for cloning')
+        .option('--wait', 'Poll until the task reaches a terminal state', false)
+        .option('--poll-interval <seconds>', 'Polling interval when --wait is used', '5')
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .action(async (prompt, options) => {
+        const music = new MusicCommand(config, logger);
+        await music.generate(prompt, options);
+    });
+    musicCommand
+        .command('status <taskId>')
+        .description('Check a queued music generation task')
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .action(async (taskId, options) => {
+        const music = new MusicCommand(config, logger);
+        await music.status(taskId, options);
+    });
     // ==================== REPO COMMANDS ====================
     // Repo command - Push/Pull projects to/from Vigthoria Repository
     const repoCommand = program
@@ -1514,7 +1545,7 @@ Examples:
     program
         .command('update')
         .alias('upgrade')
-        .description('Check for updates and upgrade Vigthoria CLI. Default manifest: https://coder.vigthoria.io/releases/manifest.json')
+        .description('Check for updates and upgrade Vigthoria CLI. Default manifest: https://extension.vigthoria.io/downloads/manifest.json')
         .option('-c, --check', 'Only check for updates, don\'t install')
         .option('-f, --from <target>', 'Install update from npm spec, local .tgz path, or URL')
         .option('-m, --manifest <url>', 'Update manifest URL for server-driven releases')

package/dist/utils/agentRunOutcome.d.ts

@@ -33,6 +33,7 @@ export interface RunEvaluation {
     uiTheme: 'success' | 'warning' | 'error';
 }
 export declare function createLiveOutcome(): LiveOutcome;
+export declare function isExecutorTimeoutFailure(liveOutcome: LiveOutcome): boolean;
 /** Tool-trace stubs like `[read_file] "index.html"` or `<read_file>…</read_file>` — not a user-facing answer. */
 export declare function isToolEvidenceStubAnswer(text: string): boolean;
 /** True when text looks like a real answer, not an executor/system placeholder. */

package/dist/utils/agentRunOutcome.js

@@ -30,6 +30,10 @@ const LIST_ONLY_DISCOVERY_TOOLS = new Set([
     'dir',
 ]);
 const GENERIC_SUMMARY_RE = /^(completed the requested analysis|reviewed the workspace without writing changes|task completed|done|finished|analysis completed)([.\s]|$)/i;
+export function isExecutorTimeoutFailure(liveOutcome) {
+    const errorText = String(liveOutcome.executorError || '').trim();
+    return /executor llm call timed out|fast fallback also failed|executor model timed out/i.test(errorText);
+}
 function looksLikeRawV3EventPayload(text) {
     const trimmed = String(text || '').trim();
     if (!/^[{[]/.test(trimmed))
@@ -164,6 +168,15 @@ export function evaluateExecutorSuccess(liveOutcome) {
         || Boolean(liveOutcome.streamAborted);
     if (liveOutcome.streamAborted && liveOutcome.tasksTotal > 0) {
         const partial = liveOutcome.tasksSucceeded > 0;
+        if (isExecutorTimeoutFailure(liveOutcome)) {
+            return {
+                executorSucceeded: false,
+                statusHeadline: partial
+                    ? `⚠ ${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal} tasks completed — executor model timed out`
+                    : `✕ Executor model timed out — 0/${liveOutcome.tasksTotal} tasks completed`,
+                uiTheme: 'warning',
+            };
+        }
         return {
             executorSucceeded: false,
             statusHeadline: partial
@@ -172,6 +185,16 @@ export function evaluateExecutorSuccess(liveOutcome) {
             uiTheme: 'warning',
         };
     }
+    if (liveOutcome.tasksTotal > 0 && isExecutorTimeoutFailure(liveOutcome)) {
+        const partial = liveOutcome.tasksSucceeded > 0;
+        return {
+            executorSucceeded: false,
+            statusHeadline: partial
+                ? `⚠ ${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal} tasks completed — executor model timed out`
+                : `✕ Executor model timed out — 0/${liveOutcome.tasksTotal} tasks completed`,
+            uiTheme: 'error',
+        };
+    }
     if (hasFatalError && liveOutcome.tasksTotal === 0) {
         return {
             executorSucceeded: false,

package/dist/utils/api.d.ts

@@ -342,6 +342,7 @@ export declare class APIClient {
     private materializeEmergencySaaSWorkspace;
     private ensureExecutionContext;
     bindExecutionContext(context?: Record<string, any>): Promise<Record<string, any>>;
+    private isServerManagedTempWorkspacePath;
     private resolveAgentTargetPath;
     private isLikelyWindowsPath;
     private resolveServerBindableWorkspacePath;

package/dist/utils/api.js

@@ -259,15 +259,18 @@ export function propagateError(err) {
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
-        return 300000;
+        return 0;
     }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
 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 rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS;
+    if (!rawValue) {
+        return 0;
+    }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
 const DEFAULT_OPERATOR_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS;
@@ -2236,6 +2239,10 @@ menu {
             }
             return {
                 ...executionContext,
+                localWorkspacePath: localWorkspacePath || executionContext.localWorkspacePath || null,
+                targetPath: localWorkspacePath || executionContext.targetPath || executionContext.projectPath || executionContext.workspacePath || null,
+                projectPath: localWorkspacePath || executionContext.projectPath || executionContext.targetPath || executionContext.workspacePath || null,
+                workspacePath: localWorkspacePath || executionContext.workspacePath || executionContext.projectPath || executionContext.targetPath || null,
                 mcpContextId: binding.mcpContextId,
                 mcpContextBackendUrl: binding.backendUrl,
             };
@@ -2276,10 +2283,38 @@ menu {
                 this.logger.debug(`Failed to bind MCP context via ${baseUrl}:`, error.message);
             }
         }
-        return executionContext;
+        return {
+            ...executionContext,
+            localWorkspacePath: localWorkspacePath || executionContext.localWorkspacePath || null,
+            targetPath: localWorkspacePath || executionContext.targetPath || executionContext.projectPath || executionContext.workspacePath || null,
+            projectPath: localWorkspacePath || executionContext.projectPath || executionContext.targetPath || executionContext.workspacePath || null,
+            workspacePath: localWorkspacePath || executionContext.workspacePath || executionContext.projectPath || executionContext.targetPath || null,
+        };
+    }
+    isServerManagedTempWorkspacePath(pathValue) {
+        const normalized = String(pathValue || '').replace(/\\/g, '/');
+        return /(?:^|\/)v3-temp\/vig-remote-/i.test(normalized)
+            || /(?:^|\/)tmp\/vig-remote(?:-server)?-/i.test(normalized)
+            || /(?:^|\/)var\/tmp\/vig-remote(?:-server)?-/i.test(normalized);
     }
     resolveAgentTargetPath(context = {}) {
-        return context.targetPath || context.projectPath || context.workspacePath || context.projectRoot || process.cwd();
+        const explicitLocal = String(context.localWorkspacePath || '').trim();
+        if (explicitLocal
+            && !explicitLocal.startsWith('vigthoria://')
+            && (this.isLikelyWindowsPath(explicitLocal) || path.isAbsolute(explicitLocal))) {
+            return explicitLocal;
+        }
+        const candidate = context.targetPath || context.projectPath || context.workspacePath || context.projectRoot || process.cwd();
+        if (this.isServerManagedTempWorkspacePath(candidate) && explicitLocal && !explicitLocal.startsWith('vigthoria://')) {
+            return explicitLocal;
+        }
+        if (this.isServerManagedTempWorkspacePath(candidate)) {
+            const preserved = String(context.__localWorkspacePath || context.clientWorkspacePath || '').trim();
+            if (preserved && !preserved.startsWith('vigthoria://')) {
+                return preserved;
+            }
+        }
+        return candidate;
     }
     isLikelyWindowsPath(pathValue) {
         return /^[a-zA-Z]:[\\/]/.test(pathValue) || /^\\\\/.test(pathValue);
@@ -2819,9 +2854,30 @@ menu {
                 return { success: true, output: matches.slice(0, 100).join('\n') || '(no matches)' };
             }
             if (name === 'syntax_check') {
-                const content = fs.readFileSync(target.absolutePath, 'utf8');
-                if (/\.json$/i.test(target.absolutePath))
-                    JSON.parse(content);
+                if (!fs.existsSync(target.absolutePath)) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `File not found: ${target.relativePath}. Write the file before running syntax_check.`,
+                    };
+                }
+                const ext = path.extname(target.absolutePath).toLowerCase();
+                if (ext === '.json') {
+                    JSON.parse(fs.readFileSync(target.absolutePath, 'utf8'));
+                    return { success: true, output: `Syntax check passed: ${target.relativePath}` };
+                }
+                if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+                    const { execSync } = await import('child_process');
+                    try {
+                        execSync(`node --check "${target.absolutePath}"`, { stdio: 'pipe' });
+                        return { success: true, output: `Syntax check passed: ${target.relativePath}` };
+                    }
+                    catch (error) {
+                        const stderr = error?.stderr?.toString?.() || error?.message || String(error);
+                        return { success: false, output: '', error: stderr.trim() || `Syntax check failed: ${target.relativePath}` };
+                    }
+                }
+                fs.readFileSync(target.absolutePath, 'utf8');
                 return { success: true, output: `Syntax check passed: ${target.relativePath}` };
             }
             if (name === 'run_command') {
@@ -2955,7 +3011,9 @@ menu {
                 return;
             }
         }
-        const targets = expectedFiles.length > 0 ? expectedFiles : Object.keys(streamedFiles);
+        const targets = expectedFiles.length > 0
+            ? Array.from(new Set([...expectedFiles, ...Object.keys(streamedFiles)]))
+            : Object.keys(streamedFiles);
         for (const targetPath of targets) {
             const relativePath = this.normalizeAgentWorkspaceRelativePath(targetPath, rootPath);
             if (!relativePath) {
@@ -3521,6 +3579,7 @@ document.addEventListener('DOMContentLoaded', () => {
         let buffer = '';
         const events = [];
         let final = null;
+        let streamDone = false;
         let contextId = response.headers.get('x-context-id') || String(context.contextId || '').trim() || null;
         let serverWorkspaceRoot = null;
         const streamedFiles = {};
@@ -3528,48 +3587,71 @@ document.addEventListener('DOMContentLoaded', () => {
         this.activeV3StreamContext = context;
         context.__v3StreamedFiles = streamedFiles;
         const idleTimeoutMs = (() => {
-            const base = context.agentIdleTimeoutMs || DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
-            if (isPlannerBuildTask(String(context.agentTaskType || ''), String(context.rawPrompt || ''))) {
-                const raw = process.env.VIGTHORIA_AGENT_PLANNER_IDLE_TIMEOUT_MS || '300000';
-                const extended = Number.parseInt(raw, 10);
-                return Math.max(base, Number.isFinite(extended) && extended > 0 ? extended : 300000);
+            const base = context.agentIdleTimeoutMs ?? DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
+            if (base <= 0) {
+                return 0;
             }
-            return base;
+            if (!isPlannerBuildTask(String(context.agentTaskType || ''), String(context.rawPrompt || ''))) {
+                return base;
+            }
+            const raw = process.env.VIGTHORIA_AGENT_PLANNER_IDLE_TIMEOUT_MS || process.env.V3_AGENT_PLANNER_IDLE_TIMEOUT_MS;
+            if (!raw) {
+                return base;
+            }
+            const extended = Number.parseInt(raw, 10);
+            return Number.isFinite(extended) && extended > 0 ? Math.max(base, extended) : base;
         })();
         try {
             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.pendingV3ClientToolTasks.size > 0) {
-                            continue;
-                        }
-                        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,
+                    if (idleTimeoutMs <= 0) {
+                        chunk = await reader.read();
+                    }
+                    else {
+                        chunk = await new Promise((resolve, reject) => {
+                            let idleTimer = null;
+                            const clearIdleTimer = () => {
+                                if (idleTimer) {
+                                    clearTimeout(idleTimer);
+                                    idleTimer = null;
+                                }
                             };
-                            throw stalledError;
-                        }
+                            const scheduleIdleTimer = () => {
+                                clearIdleTimer();
+                                idleTimer = setTimeout(() => {
+                                    if (this.pendingV3ClientToolTasks.size > 0) {
+                                        scheduleIdleTimer();
+                                        return;
+                                    }
+                                    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,
+                                        };
+                                        clearIdleTimer();
+                                        reject(stalledError);
+                                        return;
+                                    }
+                                    scheduleIdleTimer();
+                                }, idleTimeoutMs);
+                            };
+                            scheduleIdleTimer();
+                            reader.read()
+                                .then((result) => {
+                                clearIdleTimer();
+                                resolve(result);
+                            })
+                                .catch((error) => {
+                                clearIdleTimer();
+                                reject(error);
+                            });
+                        });
                     }
                 }
                 catch (error) {
@@ -3609,9 +3691,13 @@ document.addEventListener('DOMContentLoaded', () => {
                         }
                     }
                     const payload = dataLines.join('\n').trim();
-                    if (!payload || payload === '[DONE]') {
+                    if (!payload) {
                         continue;
                     }
+                    if (payload === '[DONE]') {
+                        streamDone = true;
+                        break;
+                    }
                     let event;
                     try {
                         event = JSON.parse(payload);
@@ -3702,20 +3788,9 @@ document.addEventListener('DOMContentLoaded', () => {
                     if (event.type === 'complete' || event.type === 'message') {
                         final = event;
                     }
-                    // Exit stream early on complete — agent is done; server-side teardown
-                    // can hold the connection open for many seconds otherwise.
-                    if (event.type === 'complete') {
-                        await Promise.allSettled([...this.pendingV3ClientToolTasks]);
-                        reader.cancel().catch(() => { });
-                        return {
-                            task_id: events.find((entry) => entry && entry.task_id)?.task_id || null,
-                            context_id: contextId,
-                            result: final,
-                            events,
-                            files: streamedFiles,
-                            serverWorkspaceRoot: serverWorkspaceRoot || null,
-                        };
-                    }
+                }
+                if (streamDone) {
+                    break;
                 }
             }
             await Promise.allSettled([...this.pendingV3ClientToolTasks]);
@@ -3742,11 +3817,7 @@ document.addEventListener('DOMContentLoaded', () => {
         const resolvedModel = this.resolvePermittedModelId(requestedModel);
         const preferLocalV3 = /(premium|polished|landing|site|page|dashboard|saas|frontend|ui|responsive|animated|create the required project files and write them to the workspace)/i.test(message)
             && context.localMachineCapable !== false;
-        const rescueEligibleSaaS = preferLocalV3
-            && /(saas|dashboard|analytics|billing|team management|activity feed|login screen)/i.test(message);
-        const timeoutMs = rescueEligibleSaaS
-            ? Math.min(resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || '')), 210000)
-            : resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || ''));
+        const timeoutMs = resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || ''));
         const maxAttempts = preferLocalV3 ? 2 : 1;
         let lastErrors = [];
         for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
@@ -5532,11 +5603,20 @@ document.addEventListener('DOMContentLoaded', () => {
             'vigthoria-code': 'vigthoria-v3-code-35b',
             'vigthoria-agent': 'vigthoria-v3-code-35b',
             // ═══════════════════════════════════════════════════════════════
-            // VIGTHORIA CLOUD - Premium cloud models (internal routing)
+            // VIGTHORIA CLOUD - current billing catalog aliases
             // ═══════════════════════════════════════════════════════════════
-            'cloud': 'vigthoria-cloud-pro',
-            'cloud-reason': 'vigthoria-cloud-k2',
-            'ultra': 'vigthoria-cloud-ultra',
+            'cloud': 'vigthoria-cloud-balanced',
+            'cloud-code': 'vigthoria-cloud-code',
+            'cloud-balanced': 'vigthoria-cloud-balanced',
+            'cloud-fast': 'vigthoria-cloud-fast',
+            'cloud-power': 'vigthoria-cloud-power',
+            'cloud-maximum': 'vigthoria-cloud-maximum',
+            'cloud-reason': 'vigthoria-cloud-power',
+            'ultra': 'vigthoria-cloud-maximum',
+            // Legacy aliases kept for backward compatibility
+            'cloud-pro': 'vigthoria-cloud-power',
+            'cloud-k2': 'vigthoria-cloud-power',
+            'cloud-ultra': 'vigthoria-cloud-maximum',
         };
         // If already a full model ID, return as-is
         if (shortName.includes('vigthoria') || shortName.includes('/') || shortName.includes(':')) {
@@ -5991,9 +6071,23 @@ document.addEventListener('DOMContentLoaded', () => {
     }
     async attemptV3ServiceRecovery(reason = '', _options = {}) {
         const safeReason = sanitizeUserFacingErrorText(reason || 'unknown failure');
+        const isTransient = /timed out|aborted|econnreset|fetch failed|network|503|502|504|socket hang up/i.test(safeReason);
+        if (!isTransient) {
+            return {
+                recovered: false,
+                message: safeReason ? `Recovery unavailable: ${safeReason}` : 'Recovery unavailable',
+            };
+        }
+        const health = await this.runV3HealthCheck();
+        if (!health.healthy) {
+            return {
+                recovered: false,
+                message: health.error || 'V3 service is still unreachable',
+            };
+        }
         return {
-            recovered: false,
-            message: safeReason ? `Recovery unavailable: ${safeReason}` : 'Recovery unavailable',
+            recovered: true,
+            message: 'V3 service is reachable again — retrying the workflow once.',
         };
     }
     async getDevtoolsBridgeStatus() {

package/dist/utils/config.d.ts

@@ -1,6 +1,7 @@
 export interface VigthoriaCLIConfig {
     apiUrl: string;
     modelsApiUrl: string;
+    musicApiUrl: string;
     wsUrl: string;
     selfHostedModelsApiUrl: string | null;
     authToken: string | null;

package/dist/utils/config.js

@@ -6,6 +6,7 @@ import { secureFileMode } from './cli-state.js';
 const defaultConfig = {
     apiUrl: 'https://coder.vigthoria.io',
     modelsApiUrl: 'https://api.vigthoria.io', // Direct AI Models API - no proxying through Coder
+    musicApiUrl: 'https://music.vigthoria.io',
     wsUrl: 'wss://coder.vigthoria.io/ws',
     selfHostedModelsApiUrl: null,
     authToken: null,
@@ -59,6 +60,7 @@ export class Config {
             schema: {
                 apiUrl: { type: 'string' },
                 modelsApiUrl: { type: 'string' },
+                musicApiUrl: { type: 'string' },
                 wsUrl: { type: 'string' },
                 selfHostedModelsApiUrl: { type: ['string', 'null'] },
                 authToken: { type: ['string', 'null'] },

package/dist/utils/requestIntent.js

@@ -4,8 +4,8 @@
  */
 const CLI_SHAPING_BLOCK = /(?:^|\n\n)Platform:\s*(?:Windows|macOS|Linux)\.[\s\S]*?(?=\n\n[A-Z][^\n]{0,40}:|\s*$)/i;
 const READONLY_SHAPING_BLOCK = /(?:^|\n\n)(?:Read-only analysis mode is active\.|Diagnostic mode is active\.)[\s\S]*?(?=\n\n[A-Z][^\n]{0,40}:|\s*$)/i;
-const BUILD_VERBS = /\b(build|create|make|implement|complete|fix|repair|edit|modify|write|generate|add|finish|scaffold|develop|update|change|refactor|let's|let us|we need|we should|erstelle|erstellen|schreib|schreibe|bearbeite)\b/i;
-const ARTIFACT_NOUNS = /\b(file|files|project|game|spiel|app|website|html5|frontend|component|feature|code|workspace|repo|clone|replica|remake|page|site|canvas|sprite|level|levels|enemy|enemies|character|npc|world|scene|script|module|api|database|config|landing|dashboard|platformer|arcade|playable|collectible|scoreboard|leaderboard|pitfall|pacman|rogue|html|css|javascript|typescript)\b/i;
+const BUILD_VERBS = /\b(build|create|make|implement|complete|fix|repair|edit|modify|write|generate|add|finish|scaffold|develop|update|change|refactor|want|need|require|looking for|let's|let us|we need|we should|erstelle|erstellen|schreib|schreibe|bearbeite)\b/i;
+const ARTIFACT_NOUNS = /\b(file|files|project|game|spiel|app|website|html5|frontend|component|feature|code|workspace|repo|clone|replica|remake|page|site|screen|button|popup|modal|alert|canvas|sprite|level|levels|enemy|enemies|character|npc|world|scene|script|module|api|database|config|landing|dashboard|platformer|arcade|playable|collectible|scoreboard|leaderboard|pitfall|pacman|rogue|html|css|javascript|typescript)\b/i;
 /** Canvas/playable games only — bare "html5" or "website" must NOT match. */
 const GAME_INTENT = /\b(game|spiel|playable|html5\s+(?:game|canvas)|html5\s+game|canvas\s+game|game\s+canvas|arcade|platformer|side[- ]?scroller|pitfall|pac[- ]?man|tetris|snake|breakout|pong|roguelike|metroidvania|tower\s+defense|clone\s+of\s+(?:a\s+)?(?:game|pitfall|pac|mario|zelda|arcade)|gameplay|collectible|boss\s+fight|level\s+design|sprite\s+sheet|wild\s+(?:boar|pig|forest)|forest\s+pig)\b/i;
 const WEB_PAGE_INTENT = /\b(website|web\s*site|webpage|web\s*page|landing\s+page|home\s*page|index\.html|html\s+page|static\s+page|single\s+page|popup|alert|modal|hello\s+world)\b/i;
@@ -54,7 +54,7 @@ export function isTrivialHtmlPageRequest(prompt) {
     if (isContinueOrRetryPrompt(prompt)) {
         return false;
     }
-    if (!hasBuildVerb(prompt) && !/\b(write|create|make|show)\b/i.test(text)) {
+    if (!hasBuildVerb(prompt) && !/\b(write|create|make|show|want|need|looking\s+for)\b/i.test(text)) {
         return false;
     }
     if (hasGameIntent(prompt)) {
@@ -150,10 +150,15 @@ export function resolvePlannerAgentTimeoutMs(baseTimeoutMs, agentTaskType, promp
     if (!isPlannerBuildTask(agentTaskType, prompt)) {
         return baseTimeoutMs;
     }
-    const raw = process.env.VIGTHORIA_AGENT_PLANNER_TIMEOUT_MS || process.env.V3_AGENT_PLANNER_TIMEOUT_MS || '900000';
+    const raw = process.env.VIGTHORIA_AGENT_PLANNER_TIMEOUT_MS || process.env.V3_AGENT_PLANNER_TIMEOUT_MS;
+    if (!raw) {
+        return baseTimeoutMs;
+    }
     const extended = Number.parseInt(raw, 10);
-    const floor = Number.isFinite(extended) && extended > 0 ? extended : 900000;
-    return Math.max(baseTimeoutMs, floor);
+    if (!Number.isFinite(extended) || extended <= 0) {
+        return baseTimeoutMs;
+    }
+    return Math.max(baseTimeoutMs, extended);
 }
 /** V3 workflow mode: suppress write path when the user did not ask for file changes. */
 export function resolveWorkflowType(agentTaskType, prompt) {

package/dist/utils/templateInstantPath.js

@@ -4,22 +4,108 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { stripExecutionShaping } from './requestIntent.js';
+function escapeJsString(value) {
+    return String(value || '').replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+function escapeHtml(value) {
+    return String(value || '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function extractPopupMessage(vision) {
+    const explicitShown = vision.match(/(?:popup\s+is\s+shown|popup\s+shown|shown|shows?|display(?:s|ed)?)\s*:?\s*["']([^"']+)["']/i);
+    if (explicitShown?.[1])
+        return explicitShown[1];
+    const popupPhrases = [...vision.matchAll(/popup[^"']*(?:message|text|says?|shown|with)\s*:?\s*["']([^"']+)["']/gi)];
+    if (popupPhrases.length > 0)
+        return popupPhrases[popupPhrases.length - 1][1];
+    const quoted = vision.match(/(?:alert|message)\s*(?:with|says?|text|:)\s*["']([^"']+)["']/i);
+    if (quoted?.[1])
+        return quoted[1];
+    if (/\bhello\s*world\b/i.test(vision))
+        return 'hello world';
+    return 'Hello World';
+}
+function extractButtonLabel(vision) {
+    const label = vision.match(/\blabel\s+["']([^"']+)["']/i)
+        || vision.match(/\bbutton(?:\s+(?:text|label|called|named))?\s+["']([^"']+)["']/i);
+    if (label?.[1])
+        return label[1];
+    if (/\bclick\b/i.test(vision))
+        return 'CLICK';
+    return 'Click';
+}
+function isSimplePopupButtonPrompt(vision) {
+    const text = String(vision || '').toLowerCase();
+    return /\b(popup|alert|message)\b/.test(text)
+        && /\b(button|click|label)\b/.test(text)
+        && /\bhello\s*world\b/.test(text);
+}
+function exactPopupButtonHtml(vision) {
+    const popupMessage = extractPopupMessage(vision);
+    const buttonLabel = extractButtonLabel(vision);
+    const blue = /\bblue\b/i.test(vision) ? '#0000ff' : '#0a0a1a';
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(buttonLabel)} Popup</title>
+  <style>
+    * { box-sizing: border-box; }
+    body {
+      min-height: 100vh;
+      margin: 0;
+      display: grid;
+      place-items: center;
+      background: ${blue};
+      font-family: Arial, sans-serif;
+    }
+    button {
+      padding: 14px 28px;
+      border: 0;
+      border-radius: 10px;
+      background: #ffffff;
+      color: #0000aa;
+      font-size: 20px;
+      font-weight: 700;
+      cursor: pointer;
+      box-shadow: 0 10px 30px rgba(0, 0, 0, 0.25);
+    }
+  </style>
+</head>
+<body>
+  <button id="vigthoria-popup-button" type="button">${escapeHtml(buttonLabel)}</button>
+  <script>
+    document.getElementById('vigthoria-popup-button').addEventListener('click', function () {
+      alert('${escapeJsString(popupMessage)}');
+    });
+  </script>
+</body>
+</html>
+`;
+}
 function ensurePopupScript(html, vision) {
     const text = String(vision || '').toLowerCase();
     if (!/\b(popup|alert|hello\s*world)\b/.test(text)) {
         return html;
     }
+    if (isSimplePopupButtonPrompt(vision)) {
+        return exactPopupButtonHtml(vision);
+    }
     if (/\balert\s*\(/i.test(html)) {
         return html;
     }
-    const script = "<script>window.addEventListener('load',()=>alert('Hello World'));</script>";
+    const script = `<script>document.addEventListener('DOMContentLoaded',()=>{const b=document.querySelector('button,a.cta,.cta');if(b)b.addEventListener('click',()=>alert('${escapeJsString(extractPopupMessage(vision))}'));});</script>`;
     if (/<\/body>/i.test(html)) {
         return html.replace(/<\/body>/i, `${script}\n</body>`);
     }
     return `${html}\n${script}`;
 }
 function minimalHelloWorldHtml(popupMessage = 'Hello World') {
-    const safe = String(popupMessage || 'Hello World').replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    const safe = escapeJsString(popupMessage || 'Hello World');
     return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -33,7 +119,7 @@ function minimalHelloWorldHtml(popupMessage = 'Hello World') {
 </head>
 <body>
   <h1>Hello World</h1>
-  <script>window.addEventListener('load', () => alert('${safe}'));</script>
+  <button type="button" onclick="alert('${safe}')">CLICK</button>
 </body>
 </html>
 `;
@@ -79,14 +165,6 @@ async function fetchTemplateMatch(api, vision, timeoutMs = 15000) {
     }
     return { error: lastError };
 }
-function extractPopupMessage(vision) {
-    const quoted = vision.match(/popup\s+with\s+["']([^"']+)["']/i);
-    if (quoted?.[1])
-        return quoted[1];
-    if (/\bhello\s*world\b/i.test(vision))
-        return 'Hello World';
-    return 'Hello World';
-}
 export async function runTemplateInstantPath(api, vision, workspacePath, options = {}) {
     const entryPath = options.entryPath || 'index.html';
     const target = path.join(workspacePath, entryPath);

package/dist/utils/tools.js

@@ -2554,6 +2554,7 @@ export class AgenticTools {
                 `${workspaceRootPosix}/`,
                 `${normalizedRootNoSlash}/`,
                 `${workspaceBase}/`,
+                'workspace/',
             ];
             for (const prefix of prefixes) {
                 if (candidate.startsWith(prefix)) {

package/dist/utils/v3-workspace-path.js

@@ -25,8 +25,18 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
         }
         return normalized;
     };
+    const stripWorkspaceAlias = (value) => {
+        const candidate = String(value || '').replace(/^\/+/, '');
+        if (!candidate || candidate === '.' || /^workspace\/?$/i.test(candidate)) {
+            return '';
+        }
+        if (/^workspace\//i.test(candidate)) {
+            return safeRelative(candidate.replace(/^workspace\/+/i, ''));
+        }
+        return null;
+    };
     const decodeBoundaryUri = (value) => {
-        const match = value.match(/^vigthoria:\/\/(?:workspace|server-internal)\/?(.*)$/i);
+        const match = value.match(/^vigthoria:\/\/(?:workspace|server-internal|local-workspace)\/?(.*)$/i);
         if (match) {
             return safeRelative(match[1] || '');
         }
@@ -39,6 +49,10 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
     if (/^vigthoria:\/\//i.test(input)) {
         return '';
     }
+    const workspaceAlias = stripWorkspaceAlias(input);
+    if (workspaceAlias !== null) {
+        return workspaceAlias;
+    }
     const internalWorkspacePatterns = [
         /^\/?var\/www\/\.vigthoria\/v3-temp\/vig-remote-[^/]+\/(.+)$/i,
         /^\/?var\/www\/vigthoria:\/\/?server-internal\/?(.+)$/i,

package/install.ps1

@@ -5,25 +5,33 @@
 $ErrorActionPreference = "Stop"
 
 # Configuration
-$CLI_VERSION = "1.10.18"
+$CLI_VERSION = "1.11.25"
 $INSTALL_DIR = "$env:USERPROFILE\.vigthoria"
 $NPM_PACKAGE = "vigthoria-cli"
 $GIT_PACKAGE_URL = "git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git"
-$HOSTED_TARBALL_URL = "https://coder.vigthoria.io/releases/vigthoria-cli-$CLI_VERSION.tgz"
+$MANIFEST_URL = "https://extension.vigthoria.io/downloads/manifest.json"
+$HOSTED_TARBALL_URL = "https://extension.vigthoria.io/downloads/vigthoria-cli-$CLI_VERSION.tgz"
 
-function Resolve-ReleaseTruth {
+function Resolve-ReleaseManifest {
     try {
-        $truth = Invoke-WebRequest -Uri $RELEASE_TRUTH_URL -UseBasicParsing -TimeoutSec 10 -ErrorAction Stop | Select-Object -ExpandProperty Content | ConvertFrom-Json
-        if ($truth.products.vigthoriaCli.version -and $truth.products.vigthoriaCli.url) {
-            $script:CLI_VERSION = $truth.products.vigthoriaCli.version
-            $script:HOSTED_TARBALL_URL = $truth.products.vigthoriaCli.url
+        $manifest = Invoke-WebRequest -Uri $MANIFEST_URL -UseBasicParsing -TimeoutSec 10 -ErrorAction Stop |
+            Select-Object -ExpandProperty Content |
+            ConvertFrom-Json
+        $stable = $manifest.channels.stable
+        if ($stable.version) {
+            $script:CLI_VERSION = [string]$stable.version
+        }
+        if ($stable.url) {
+            $script:HOSTED_TARBALL_URL = [string]$stable.url
+        } elseif ($stable.version) {
+            $script:HOSTED_TARBALL_URL = "https://extension.vigthoria.io/downloads/vigthoria-cli-$($stable.version).tgz"
         }
     } catch {
-        Write-Host "Release truth unavailable, using bundled fallback $CLI_VERSION" -ForegroundColor Yellow
+        Write-Host "Release manifest unavailable, using bundled fallback $CLI_VERSION" -ForegroundColor Yellow
     }
 }
 
-Resolve-ReleaseTruth
+Resolve-ReleaseManifest
 
 function Write-Banner {
     Write-Host ""

package/install.sh

@@ -26,11 +26,54 @@ else
 fi
 
 # Configuration
-CLI_VERSION="1.10.18"
+CLI_VERSION="1.11.25"
 INSTALL_DIR="$HOME/.vigthoria"
 REPO_URL="https://market.vigthoria.io/vigthoria/vigthoria-cli"
 GIT_PACKAGE_URL="git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git"
-HOSTED_TARBALL_URL="https://coder.vigthoria.io/releases/vigthoria-cli-${CLI_VERSION}.tgz"
+MANIFEST_URL="${VIGTHORIA_UPDATE_MANIFEST_URL:-https://extension.vigthoria.io/downloads/manifest.json}"
+HOSTED_TARBALL_URL="https://extension.vigthoria.io/downloads/vigthoria-cli-${CLI_VERSION}.tgz"
+
+resolve_release_manifest() {
+    if ! command -v curl >/dev/null 2>&1 || ! command -v python3 >/dev/null 2>&1; then
+        return 0
+    fi
+
+    local manifest_json
+    manifest_json="$(curl -fsSL "$MANIFEST_URL" 2>/dev/null || true)"
+    if [[ -z "$manifest_json" ]]; then
+        return 0
+    fi
+
+    local resolved
+    resolved="$(printf '%s' "$manifest_json" | python3 -c "
+import json, sys
+try:
+    data = json.load(sys.stdin)
+    stable = (data.get('channels') or {}).get('stable') or {}
+    version = str(stable.get('version') or '').strip()
+    url = str(stable.get('url') or '').strip()
+    if version:
+        print(version)
+    if url:
+        print(url)
+except Exception:
+    pass
+" 2>/dev/null || true)"
+
+    if [[ -n "$resolved" ]]; then
+        mapfile -t _manifest_lines <<< "$resolved"
+        if [[ -n "${_manifest_lines[0]:-}" ]]; then
+            CLI_VERSION="${_manifest_lines[0]}"
+        fi
+        if [[ -n "${_manifest_lines[1]:-}" ]]; then
+            HOSTED_TARBALL_URL="${_manifest_lines[1]}"
+        elif [[ -n "${_manifest_lines[0]:-}" ]]; then
+            HOSTED_TARBALL_URL="https://extension.vigthoria.io/downloads/vigthoria-cli-${CLI_VERSION}.tgz"
+        fi
+    fi
+}
+
+resolve_release_manifest
 
 # Detect platform and set appropriate bin directory
 detect_platform() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.11.19",
+  "version": "1.11.27",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",

package/scripts/release/publish-cli-release.sh

@@ -17,7 +17,7 @@ REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 PKG_FILE="$REPO_ROOT/vigthoria-cli-${VERSION}.tgz"
 HOST_DOWNLOADS_DIR="${HOST_DOWNLOADS_DIR:-}"
 HOST_MANIFEST_FILE="${HOST_MANIFEST_FILE:-}"
-PUBLIC_BASE_URL="${PUBLIC_BASE_URL:-https://cli.vigthoria.io/downloads}"
+PUBLIC_BASE_URL="${PUBLIC_BASE_URL:-https://extension.vigthoria.io/downloads}"
 CHANNEL="${CHANNEL:-stable}"
 
 if [[ ! -f "$PKG_FILE" ]]; then