vigthoria-cli 1.6.23 → 1.6.25

package/dist/commands/auth.js

@@ -199,11 +199,20 @@ class AuthCommand {
             console.log(chalk_1.default.gray('  Self-hosted Models: ') + chalk_1.default.gray('disabled'));
         }
         const capabilitySpinner = (0, logger_js_1.createSpinner)('Checking live capability truth...').start();
-        const capabilityStatus = await this.api.getCapabilityTruthStatus({
-            workspacePath: process.cwd(),
-            projectPath: process.cwd(),
-            targetPath: process.cwd(),
-        });
+        const capabilityStatus = await Promise.race([
+            this.api.getCapabilityTruthStatus({
+                workspacePath: process.cwd(),
+                projectPath: process.cwd(),
+                targetPath: process.cwd(),
+            }),
+            new Promise(resolve => setTimeout(() => resolve({
+                overallOk: false,
+                v3Agent: { name: 'V3 Agent', endpoint: '', ok: false, error: 'Timed out (8s)' },
+                hyperLoop: { name: 'Hyper Loop', endpoint: '', ok: false, error: 'Timed out (8s)' },
+                repoMemory: { name: 'Repo Memory', endpoint: '', ok: false, error: 'Timed out (8s)' },
+                devtoolsBridge: { name: 'DevTools Bridge', endpoint: '', ok: false, error: 'Timed out (8s)' },
+            }), 8000)),
+        ]);
         capabilitySpinner.stop();
         console.log();
         console.log(chalk_1.default.white('Capability Truth:'));

package/dist/commands/chat.d.ts

@@ -75,6 +75,13 @@ export declare class ChatCommand {
     private slugifyWorkspaceName;
     private allocateManagedWorkspacePath;
     private initializeSession;
+    /**
+     * Determine whether a direct --prompt call is simple enough to skip the
+     * full V3 Agent planner and answer directly via the simple chat pipeline.
+     * This prevents trivial prompts like "Reply with OK" from triggering a
+     * multi-step planning workflow with quality_profile: premium-visual-build.
+     */
+    private isSimpleDirectPrompt;
     private handleDirectPrompt;
     private formatWorkflowTargetResult;
     private runWorkflowTargetPrompt;

package/dist/commands/chat.js

@@ -486,7 +486,37 @@ class ChatCommand {
         if (options.newProject) {
             return true;
         }
-        return Boolean(options.prompt) && (options.agent === true || options.operator === true);
+        // Only use managed workspace when --prompt is given AND the CWD looks
+        // like a home/root directory (no project signals).  When the user runs
+        // `vigthoria agent --prompt "..."` inside an actual project folder we
+        // should use that folder, not invent a new managed workspace.
+        if (Boolean(options.prompt) && (options.agent === true || options.operator === true)) {
+            const cwd = process.cwd();
+            const homeDir = os.homedir();
+            // If CWD is home dir, root, or a system temp dir → use managed workspace
+            if (cwd === homeDir || cwd === '/' || cwd === 'C:\\' || cwd.toLowerCase().includes('temp')) {
+                return true;
+            }
+            // If CWD has any project signals → use CWD
+            const projectSignals = ['.git', 'package.json', 'Cargo.toml', 'go.mod', 'pom.xml', 'requirements.txt', 'pyproject.toml', '.vigthoria', 'Makefile', 'CMakeLists.txt', 'tsconfig.json'];
+            for (const signal of projectSignals) {
+                if (fs.existsSync(path.join(cwd, signal))) {
+                    return false;
+                }
+            }
+            // If CWD has files (not just an empty dir) → use CWD
+            try {
+                const entries = fs.readdirSync(cwd);
+                if (entries.length > 0) {
+                    return false;
+                }
+            }
+            catch {
+                // Cannot read CWD — fall through to managed workspace
+            }
+            return true;
+        }
+        return false;
     }
     getManagedWorkspaceRoot() {
         const envRoot = String(process.env.VIGTHORIA_DEFAULT_WORKSPACE_ROOT || '').trim();
@@ -546,6 +576,27 @@ class ChatCommand {
         this.currentSession = this.sessionManager.create(this.currentProjectPath, this.currentModel, this.agentMode, this.operatorMode);
         this.messages = [...this.currentSession.messages];
     }
+    /**
+     * Determine whether a direct --prompt call is simple enough to skip the
+     * full V3 Agent planner and answer directly via the simple chat pipeline.
+     * This prevents trivial prompts like "Reply with OK" from triggering a
+     * multi-step planning workflow with quality_profile: premium-visual-build.
+     */
+    isSimpleDirectPrompt(prompt) {
+        const trimmed = prompt.trim();
+        // Short prompts (≤ 12 words) that don't reference files, builds, or code tasks
+        const wordCount = trimmed.split(/\s+/).length;
+        if (wordCount <= 12 && !/(create|build|generate|implement|write.*function|add.*feature|refactor|deploy|fix|edit|modify|update|delete|remove)\b/i.test(trimmed)) {
+            return true;
+        }
+        // Conversational / Q&A prompts
+        if (/^(what|who|when|where|why|how|is|are|do|does|can|could|would|should|tell|explain|describe|list|show|help|reply|say|respond|answer|translate|summarize|define)\b/i.test(trimmed)) {
+            if (!/(file|code|project|workspace|repo|module|component|function|class|api|endpoint|route|database|schema|migration|docker|deploy|build|test)\b/i.test(trimmed)) {
+                return true;
+            }
+        }
+        return false;
+    }
     async handleDirectPrompt(prompt) {
         if (!this.jsonOutput) {
             console.log(chalk_1.default.cyan('Running single prompt in direct mode.'));
@@ -560,7 +611,8 @@ class ChatCommand {
             await this.runWorkflowTargetPrompt(prompt);
             return;
         }
-        if (this.agentMode) {
+        // Smart routing: skip agent planner for simple/conversational prompts
+        if (this.agentMode && !this.isSimpleDirectPrompt(prompt)) {
             await this.runAgentTurn(prompt);
             return;
         }
@@ -1581,7 +1633,7 @@ class ChatCommand {
         if (this.isServerBindableWorkspace(this.currentProjectPath)) {
             return false;
         }
-        return /(analyse|analyze|audit|overview|inspect|explain|review|debug|diagnos|read|summari[sz]e|investigate)/i.test(prompt);
+        return /(analyse|analyze|audit|overview|inspect|explain|review|debug|diagnos|read|summari[sz]e|investigate|list|show|find|search|check|scan|count|what|describe)/i.test(prompt);
     }
     shouldRequireV3AgentWorkflow(prompt) {
         if (!this.directPromptMode) {

package/dist/commands/generate.d.ts

@@ -28,5 +28,10 @@ export declare class GenerateCommand {
     private saveToFile;
     private promptForAction;
     private suggestFilename;
+    /**
+     * Auto-detect the target language from the user's description.
+     * Falls back to 'javascript' if no language is recognized.
+     */
+    private detectLanguageFromDescription;
 }
 export {};

package/dist/commands/generate.js

@@ -33,6 +33,10 @@ class GenerateCommand {
         }
         // Determine mode
         const proMode = options.pro === true;
+        // Auto-detect language from description if not explicitly specified
+        if (!options.language) {
+            options.language = this.detectLanguageFromDescription(description);
+        }
         this.logger.section(proMode ? '🚀 Senior Developer Mode' : 'Code Generation');
         console.log(chalk_1.default.gray(`Language: ${options.language}`));
         console.log(chalk_1.default.gray(`Description: ${description}`));
@@ -214,5 +218,40 @@ class GenerateCommand {
         };
         return extensions[language] || 'generated.txt';
     }
+    /**
+     * Auto-detect the target language from the user's description.
+     * Falls back to 'javascript' if no language is recognized.
+     */
+    detectLanguageFromDescription(description) {
+        const lower = description.toLowerCase();
+        const patterns = [
+            [/\b(typescript|\.ts\b)/i, 'typescript'],
+            [/\b(javascript|\.js\b|node\.?js|es6|ecmascript)\b/i, 'javascript'],
+            [/\b(python|\.py\b|django|flask|fastapi)\b/i, 'python'],
+            [/\b(rust|\.rs\b|cargo)\b/i, 'rust'],
+            [/\b(go|golang|\.go\b)\b/i, 'go'],
+            [/\b(java\b|\.java\b|spring\b)/i, 'java'],
+            [/\b(c#|csharp|\.cs\b|dotnet|\.net)\b/i, 'csharp'],
+            [/\b(c\+\+|cpp|\.cpp\b|\.hpp\b)\b/i, 'cpp'],
+            [/\b(ruby|\.rb\b|rails)\b/i, 'ruby'],
+            [/\b(php|\.php\b|laravel)\b/i, 'php'],
+            [/\b(swift|\.swift\b|swiftui)\b/i, 'swift'],
+            [/\b(kotlin|\.kt\b)\b/i, 'kotlin'],
+            [/\b(html|\.html\b|webpage|web page|website|landing page)\b/i, 'html'],
+            [/\b(css|\.css\b|stylesheet)\b/i, 'css'],
+            [/\b(sql|\.sql\b|database query|select\s+\*)\b/i, 'sql'],
+            [/\b(bash|shell|\.sh\b|script)\b/i, 'bash'],
+        ];
+        for (const [regex, lang] of patterns) {
+            if (regex.test(lower)) {
+                return lang;
+            }
+        }
+        // If the description mentions "function" without any language hint, default to javascript
+        if (/\bfunction\b/i.test(lower)) {
+            return 'javascript';
+        }
+        return 'javascript';
+    }
 }
 exports.GenerateCommand = GenerateCommand;

package/dist/index.js

@@ -98,7 +98,7 @@ function getVersion() {
     catch (e) {
         // Fallback to hardcoded version
     }
-    return '1.6.22';
+    return '1.6.25';
 }
 const VERSION = getVersion();
 /**
@@ -334,7 +334,7 @@ async function main() {
         .command('generate <description>')
         .alias('g')
         .description('Generate code from description')
-        .option('-l, --language <lang>', 'Target language (html, typescript, python, etc.)', 'html')
+        .option('-l, --language <lang>', 'Target language (auto-detected from description, or specify: javascript, typescript, python, html, etc.)')
         .option('-o, --output <file>', 'Output file path')
         .option('-m, --model <model>', 'Select AI model', 'code')
         .option('-p, --pro', 'Senior Developer Mode: plan, generate, quality check (recommended)', false)

package/dist/utils/api.d.ts

@@ -320,6 +320,30 @@ export declare class APIClient {
     chatStream(messages: ChatMessage[], model: string): AsyncGenerator<StreamChunk>;
     chatWithCallback(messages: ChatMessage[], model: string, onChunk: (chunk: string) => void, onDone: () => void, onError: (error: Error) => void): Promise<void>;
     generateCode(prompt: string, language: string, model: string): Promise<string>;
+    /**
+     * Ensure code has balanced curly braces by appending missing closing braces.
+     */
+    private ensureBalancedBraces;
+    /**
+     * Extract the first complete function/class from code.
+     * Used as last-resort when the model keeps over-producing.
+     */
+    private extractFirstFunction;
+    /**
+     * Detect if code is excessively over-engineered for a short prompt.
+     * E.g. a "multiply function" request producing 20+ lines.
+     */
+    private codeIsOverEngineered;
+    /**
+     * Detect if generated code contains DOM/HTML pollution inappropriate
+     * for a pure programming language like JavaScript, Python, etc.
+     */
+    private codeContainsDomPollution;
+    /**
+     * Strip DOM pollution from generated code, keeping only the pure logic.
+     * Used as last-resort fallback when the model repeatedly ignores constraints.
+     */
+    private stripDomPollution;
     generateProject(prompt: string, projectType: string, model: string): Promise<{
         code: string;
         plan?: any;

package/dist/utils/api.js

@@ -990,6 +990,9 @@ class APIClient {
         let json = JSON.stringify(payload);
         if (json.length <= LIMIT)
             return json;
+        if (process.env.DEBUG || process.env.VIGTHORIA_DEBUG) {
+            console.log(`[context] Payload ${json.length} chars exceeds ${LIMIT} limit, compacting...`);
+        }
         // Phase 1 — shrink workspaceFiles to fit
         const summary = payload.localWorkspaceSummary;
         if (summary?.workspaceFiles && typeof summary.workspaceFiles === 'object') {
@@ -3239,31 +3242,171 @@ document.addEventListener('DOMContentLoaded', () => {
     }
     // Code operations - Using Vigthoria Centralized API
     async generateCode(prompt, language, model) {
+        const isNonHtmlLang = !['html', 'css'].includes(language.toLowerCase());
+        const wordCount = prompt.trim().split(/\s+/).length;
         // Prepend a forceful scope-enforcement instruction so the model
         // doesn't expand a small task into an oversized glossy page.
-        const scopedPrompt = [
-            'IMPORTANT — MANDATORY SCOPE CONSTRAINTS (violation = failure):',
-            '1. Output ONLY what the user explicitly asked for. Nothing more.',
-            '2. If the prompt is ≤ 15 words, produce ≤ 80 lines of code maximum.',
-            '3. If the user says "tiny", "small", "simple", "minimal", or "basic", produce ≤ 50 lines.',
-            '4. NEVER add any of these unless the user EXPLICITLY requests them:',
-            '   - Hero sections, CTAs, testimonials, pricing tables, footers, navbars',
-            '   - CSS animations, gradients, neon effects, glass-morphism, particles',
-            '   - Google Fonts, Font Awesome, external CDN links, icon libraries',
-            '   - Responsive breakpoints, media queries (unless asked)',
-            '   - Multiple pages or components when one was requested',
-            '5. Prefer inline styles or a small <style> block. No CSS frameworks.',
-            '6. Return raw code only — no markdown fences, no explanations, no comments about what could be added.',
-            '7. Match the complexity of the request: a "hello world" is 1-5 lines, a "button" is 5-15 lines.',
-            '',
-            prompt,
-        ].join('\n');
-        const response = await this.client.post('/api/ai/generate', {
-            prompt: scopedPrompt,
+        const buildScopedPrompt = (retry) => {
+            if (retry && isNonHtmlLang) {
+                // Ultra-minimal retry prompt — no long instruction block
+                return `OUTPUT ONLY RAW ${language.toUpperCase()} CODE. MAXIMUM 10 LINES. NO DOM. NO HTML. NO CSS. NO ANIMATION. NO VALIDATION. NO COMMENTS.\n\n${prompt}`;
+            }
+            const lines = [
+                'IMPORTANT — MANDATORY SCOPE CONSTRAINTS (violation = failure):',
+                `1. You MUST output ONLY ${language.toUpperCase()} code. Do NOT output HTML, CSS, or DOM manipulation unless the language is html/css.`,
+                `2. The target language is: ${language}. Do not switch to a different language.`,
+                '3. Output ONLY what the user explicitly asked for. Nothing more.',
+                '4. If the prompt is ≤ 15 words, produce ≤ 80 lines of code maximum.',
+                '5. If the user says "tiny", "small", "simple", "minimal", or "basic", produce ≤ 50 lines.',
+                '6. NEVER add any of these unless the user EXPLICITLY requests them:',
+                '   - Hero sections, CTAs, testimonials, pricing tables, footers, navbars',
+                '   - CSS animations, gradients, neon effects, glass-morphism, particles',
+                '   - Google Fonts, Font Awesome, external CDN links, icon libraries',
+                '   - DOM manipulation, document.createElement, innerHTML',
+                '   - Responsive breakpoints, media queries (unless asked)',
+                '   - Multiple pages or components when one was requested',
+                '   - Input validation, error handling beyond what was requested',
+                '7. Prefer inline styles or a small <style> block ONLY if the language is html. No CSS frameworks.',
+                '8. Return raw code only — no markdown fences, no explanations, no comments about what could be added.',
+                '9. Match the complexity of the request: a "hello world" is 1-5 lines, a "multiply function" is 3-5 lines, a "button" is 5-15 lines.',
+            ];
+            if (isNonHtmlLang) {
+                lines.push(`10. This is a PURE ${language.toUpperCase()} task. ABSOLUTELY NO document.*, window.*, DOM, createElement, innerHTML, querySelector, addEventListener. Output a plain ${language} function/module ONLY.`);
+            }
+            lines.push('', prompt);
+            return lines.join('\n');
+        };
+        // First attempt
+        let response = await this.client.post('/api/ai/generate', {
+            prompt: buildScopedPrompt(false),
             language,
             model: this.resolvePermittedModelId(model),
         });
-        return response.data.code;
+        let code = response.data.code || '';
+        // Client-side validation: reject DOM-polluted or over-engineered responses for non-HTML languages
+        const needsRetry = isNonHtmlLang && (this.codeContainsDomPollution(code) ||
+            this.codeIsOverEngineered(code, prompt));
+        if (needsRetry) {
+            // Retry once with stronger constraint
+            response = await this.client.post('/api/ai/generate', {
+                prompt: buildScopedPrompt(true),
+                language,
+                model: this.resolvePermittedModelId(model),
+            });
+            code = response.data.code || '';
+            // If still polluted, strip DOM code client-side
+            if (this.codeContainsDomPollution(code)) {
+                code = this.stripDomPollution(code, language);
+            }
+        }
+        // Final cleanup: for non-HTML, if still over-engineered after retry,
+        // extract only the first complete function/class definition.
+        if (isNonHtmlLang && this.codeIsOverEngineered(code, prompt)) {
+            code = this.extractFirstFunction(code);
+        }
+        // Ensure balanced braces — model sometimes truncates closing braces
+        code = this.ensureBalancedBraces(code);
+        return code;
+    }
+    /**
+     * Ensure code has balanced curly braces by appending missing closing braces.
+     */
+    ensureBalancedBraces(code) {
+        let depth = 0;
+        for (const ch of code) {
+            if (ch === '{')
+                depth++;
+            else if (ch === '}')
+                depth--;
+        }
+        if (depth > 0) {
+            const trimmed = code.trimEnd();
+            for (let i = 0; i < depth; i++) {
+                code = trimmed + '\n};';
+            }
+        }
+        return code;
+    }
+    /**
+     * Extract the first complete function/class from code.
+     * Used as last-resort when the model keeps over-producing.
+     */
+    extractFirstFunction(code) {
+        const lines = code.split('\n');
+        const funcStart = lines.findIndex(l => /^(export\s+)?(const\s+\w+\s*=\s*(\(|function)|function\s+\w+|class\s+\w+|def\s+\w+|fn\s+\w+|func\s+\w+)/.test(l.trim()));
+        if (funcStart === -1)
+            return code;
+        let braceDepth = 0;
+        let foundOpen = false;
+        const result = [];
+        for (let i = funcStart; i < lines.length; i++) {
+            const line = lines[i];
+            result.push(line);
+            braceDepth += (line.match(/{/g) || []).length;
+            braceDepth -= (line.match(/}/g) || []).length;
+            if (braceDepth > 0)
+                foundOpen = true;
+            if (foundOpen && braceDepth <= 0) {
+                break;
+            }
+        }
+        // If we reached the end without balancing braces, add closing
+        if (braceDepth > 0) {
+            result.push('};');
+        }
+        return result.join('\n');
+    }
+    /**
+     * Detect if code is excessively over-engineered for a short prompt.
+     * E.g. a "multiply function" request producing 20+ lines.
+     */
+    codeIsOverEngineered(code, prompt) {
+        const wordCount = prompt.trim().split(/\s+/).length;
+        const lineCount = code.trim().split('\n').length;
+        // Short prompt (≤15 words) should not produce more than 15 lines
+        if (wordCount <= 15 && lineCount > 15)
+            return true;
+        return false;
+    }
+    /**
+     * Detect if generated code contains DOM/HTML pollution inappropriate
+     * for a pure programming language like JavaScript, Python, etc.
+     */
+    codeContainsDomPollution(code) {
+        const domPatterns = /document\.(createElement|querySelector|getElementById|getElementsBy|body|head|addEventListener)|innerHTML|\.style\.(cssText|position|transform|animation)|@keyframes|\.appendChild|\.removeChild|window\.(onload|addEventListener)/;
+        return domPatterns.test(code);
+    }
+    /**
+     * Strip DOM pollution from generated code, keeping only the pure logic.
+     * Used as last-resort fallback when the model repeatedly ignores constraints.
+     */
+    stripDomPollution(code, language) {
+        const lines = code.split('\n');
+        const cleanLines = [];
+        let insideDomBlock = false;
+        let braceDepth = 0;
+        for (const line of lines) {
+            // Detect start of DOM blocks
+            if (/document\.|\.style\.|\.appendChild|\.removeChild|\.textContent\s*=|@keyframes|addEventListener/.test(line) && !insideDomBlock) {
+                insideDomBlock = true;
+                braceDepth = 0;
+            }
+            if (insideDomBlock) {
+                braceDepth += (line.match(/{/g) || []).length;
+                braceDepth -= (line.match(/}/g) || []).length;
+                if (braceDepth <= 0) {
+                    insideDomBlock = false;
+                }
+                continue; // Skip DOM lines
+            }
+            cleanLines.push(line);
+        }
+        const cleaned = cleanLines.join('\n').trim();
+        // If we stripped too aggressively (less than 2 lines left), return a minimal stub
+        if (cleaned.split('\n').length < 2) {
+            return `// Auto-generated: model returned DOM code for a ${language} task.\n// Please regenerate or provide more specific instructions.`;
+        }
+        return cleaned;
     }
     // Senior Developer Mode - Planning + Generation + Quality Check
     async generateProject(prompt, projectType, model) {
@@ -3386,6 +3529,36 @@ document.addEventListener('DOMContentLoaded', () => {
                     }
                 }
             }
+            // Accumulator/reducer bug: subtraction used in a reduce/total/sum context
+            // e.g. "sum - item.price" in a function named calculateTotal, getTotal, etc.
+            if (/\w+\s*-\s*\w+\.\s*(price|cost|amount|value|total|quantity|count)\b/.test(line) || /\w+\.\s*(price|cost|amount|value|total)\s*-\s*/.test(line)) {
+                // Check enclosing function/method name for total/sum/aggregate semantics
+                for (let j = i; j >= Math.max(0, i - 10); j--) {
+                    if (/(function\s+)?(calculate|calc|get|compute|sum|total|aggregate|accumulate)\s*(Total|Sum|Cost|Price|Amount|All)?\s*[=(]/i.test(lines[j]) || /\.(reduce|forEach|map)\s*\(/.test(lines[j])) {
+                        // Also check if this looks like an accumulator pattern (sum - something instead of sum + something)
+                        if (/\w+\s*-\s*\w+\.\s*(price|cost|amount|value|total|quantity)\b/.test(line)) {
+                            issues.push({ type: 'logic', line: lineNum, message: 'Subtraction used in an accumulation context (total/sum/reduce) — likely should be addition (+).', severity: 'error' });
+                        }
+                        break;
+                    }
+                }
+            }
+            // Mismatched function name vs operator: sum/total function using wrong operator
+            if (/\breturn\b/.test(line)) {
+                for (let j = i; j >= Math.max(0, i - 8); j--) {
+                    const funcMatch = lines[j].match(/function\s+(\w+)/i) || lines[j].match(/(?:const|let|var)\s+(\w+)\s*=/i);
+                    if (funcMatch) {
+                        const funcName = funcMatch[1].toLowerCase();
+                        if ((funcName.includes('total') || funcName.includes('sum') || funcName.includes('add')) && /\s-\s/.test(line) && !/\s\+\s/.test(line)) {
+                            const alreadyReported = issues.some(iss => iss.line === lineNum && iss.type === 'logic');
+                            if (!alreadyReported) {
+                                issues.push({ type: 'logic', line: lineNum, message: `Subtraction operator in "${funcMatch[1]}" — function name implies addition. Likely should use + instead of -.`, severity: 'error' });
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
             // Off-by-one: comparing with === where <= or >= may be needed
             // (not implemented yet — would require more complex AST analysis)
             // Limit to 15 heuristic issues
@@ -3398,8 +3571,14 @@ document.addEventListener('DOMContentLoaded', () => {
         // Client-side syntax pre-check: detect obvious errors and include
         // them in the request so the model has concrete signals.
         const syntaxHints = this.detectSyntaxErrors(code, language);
-        const augmentedCode = syntaxHints
-            ? `// SYNTAX ERRORS DETECTED BY CLIENT:\n// ${syntaxHints}\n\n${code}`
+        // Also run heuristic logic analysis to find real bugs
+        const heuristicIssues = this.heuristicCodeIssues(code, language);
+        const logicHints = heuristicIssues
+            .map(i => `Line ${i.line}: [${i.type}] ${i.message}`)
+            .join('\n// ');
+        const allHints = [syntaxHints, logicHints].filter(Boolean).join('\n// ');
+        const augmentedCode = allHints
+            ? `// BUGS DETECTED BY STATIC ANALYSIS — YOU MUST FIX THESE:\n// ${allHints}\n\n${code}`
             : code;
         const response = await this.client.post('/api/ai/fix', {
             code: augmentedCode,
@@ -3409,23 +3588,41 @@ document.addEventListener('DOMContentLoaded', () => {
         const raw = response.data ?? {};
         let fixed = typeof raw.fixed === 'string' ? raw.fixed : (typeof raw.code === 'string' ? raw.code : code);
         let changes = Array.isArray(raw.changes) ? raw.changes : [];
-        // If server returned no changes but we found syntax errors, strip
+        // If server returned no changes but we found issues, strip
         // our injected comment prefix from the returned code and attempt
         // a basic client-side repair.
-        if (changes.length === 0 && syntaxHints && fixed === augmentedCode) {
+        if (changes.length === 0 && allHints && fixed === augmentedCode) {
             fixed = code; // restore original
         }
         // Strip the injected comment block if it leaked into the output
-        if (fixed.startsWith('// SYNTAX ERRORS DETECTED BY CLIENT:')) {
+        if (fixed.startsWith('// BUGS DETECTED BY STATIC ANALYSIS') || fixed.startsWith('// SYNTAX ERRORS DETECTED BY CLIENT:')) {
             const idx = fixed.indexOf('\n\n');
             if (idx !== -1) {
                 fixed = fixed.slice(idx + 2);
             }
         }
-        // If there are still no changes but the fixed code differs, build a
-        // synthetic change entry so the user sees something actionable.
+        // If there are still no changes but the fixed code differs, compute
+        // a line-level diff so the user sees exactly what changed.
         if (changes.length === 0 && fixed !== code) {
-            changes = [{ line: 1, before: '(original code)', after: '(fixed code)', reason: syntaxHints || 'AI-suggested fix' }];
+            const origLines = code.split('\n');
+            const fixedLines = fixed.split('\n');
+            const maxLen = Math.max(origLines.length, fixedLines.length);
+            for (let i = 0; i < maxLen; i++) {
+                const orig = origLines[i] ?? '';
+                const fixd = fixedLines[i] ?? '';
+                if (orig !== fixd) {
+                    changes.push({
+                        line: i + 1,
+                        before: orig || '(empty line)',
+                        after: fixd || '(line removed)',
+                        reason: allHints || 'AI-suggested fix',
+                    });
+                }
+            }
+            // If diff produced nothing (whitespace-only?), at least show a summary
+            if (changes.length === 0) {
+                changes = [{ line: 1, before: '(whitespace changes)', after: '(see fixed file)', reason: allHints || 'AI-suggested fix' }];
+            }
         }
         return { fixed, changes };
     }
@@ -3712,7 +3909,8 @@ document.addEventListener('DOMContentLoaded', () => {
         };
     }
     async getHyperLoopHealth() {
-        const endpoint = process.env.VIGTHORIA_HYPERLOOP_URL || 'http://127.0.0.1:8020/api/hyperloop/health';
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const endpoint = process.env.VIGTHORIA_HYPERLOOP_URL || `${configuredApiUrl}/api/hyperloop/health`;
         try {
             const token = this.getAccessToken();
             const response = await fetch(endpoint, {
@@ -3741,8 +3939,9 @@ document.addEventListener('DOMContentLoaded', () => {
         }
     }
     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 configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const endpoint = process.env.VIGTHORIA_HYPERLOOP_EXECUTE_URL || `${configuredApiUrl}/api/hyperloop/execute`;
+        const modulesEndpoint = process.env.VIGTHORIA_HYPERLOOP_MODULES_URL || `${configuredApiUrl}/api/hyperloop/modules`;
         const token = this.getAccessToken();
         const projectPath = this.resolveAgentTargetPath(context);
         try {

package/dist/utils/bridge-client.js

@@ -53,6 +53,7 @@ exports.BridgeClient = void 0;
 exports.getBridgeClient = getBridgeClient;
 const ws_1 = __importDefault(require("ws"));
 const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
 // ── Singleton accessor ───────────────────────────────────────────────
 let _instance = null;
 /** Get the active bridge client (may be null if --bridge was not used). */
@@ -134,6 +135,9 @@ class BridgeClient {
                     this.connected = false;
                     this.stopHeartbeat();
                     this.scheduleReconnect();
+                    if (process.env.DEBUG || process.env.VIGTHORIA_DEBUG) {
+                        console.log(chalk_1.default.yellow('⚠ Bridge: connection failed, will retry in background.'));
+                    }
                     resolve(); // resolve even on failure – must never block CLI
                 });
             }

package/package.json

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