vigthoria-cli 1.6.28 → 1.6.30

package/dist/commands/auth.js

@@ -217,25 +217,39 @@ class AuthCommand {
         console.log();
         console.log(chalk_1.default.white('Capability Truth:'));
         console.log(chalk_1.default.gray('  Overall: ') + (capabilityStatus.overallOk ? chalk_1.default.green('Verified') : chalk_1.default.yellow('Partial')));
+        // V3 Agent — used by agent/chat commands
         console.log(chalk_1.default.gray('  V3 Agent: ') + (capabilityStatus.v3Agent.ok ? chalk_1.default.green('Reachable') : chalk_1.default.red('Unavailable')));
         if (capabilityStatus.v3Agent.error) {
             console.log(chalk_1.default.gray('    Error: ') + chalk_1.default.red(capabilityStatus.v3Agent.error));
         }
-        console.log(chalk_1.default.gray('  Hyper Loop: ') + (capabilityStatus.hyperLoop.ok ? chalk_1.default.green('Reachable') : chalk_1.default.red('Unavailable')));
+        // Hyper Loop — optional orchestration layer
+        console.log(chalk_1.default.gray('  Hyper Loop: ') + (capabilityStatus.hyperLoop.ok ? chalk_1.default.green('Reachable') : chalk_1.default.yellow('Unavailable (does not affect AI commands)')));
         if (capabilityStatus.hyperLoop.error) {
-            console.log(chalk_1.default.gray('    Error: ') + chalk_1.default.red(capabilityStatus.hyperLoop.error));
+            console.log(chalk_1.default.gray('    Error: ') + chalk_1.default.yellow(capabilityStatus.hyperLoop.error));
         }
-        console.log(chalk_1.default.gray('  Repo Memory: ') + (capabilityStatus.repoMemory.ok ? chalk_1.default.green('Active') : chalk_1.default.yellow('Unavailable')));
+        // Repo Memory — separate auth scope, only affects repo commands
+        console.log(chalk_1.default.gray('  Repo Memory: ') + (capabilityStatus.repoMemory.ok ? chalk_1.default.green('Active') : chalk_1.default.yellow('Unavailable (does not affect AI commands)')));
         if (capabilityStatus.repoMemory.details?.compactContextLength !== undefined) {
             console.log(chalk_1.default.gray('    Compact Context: ') + chalk_1.default.cyan(`${capabilityStatus.repoMemory.details.compactContextLength} chars`));
         }
         if (capabilityStatus.repoMemory.error) {
             console.log(chalk_1.default.gray('    Error: ') + chalk_1.default.yellow(capabilityStatus.repoMemory.error));
         }
-        console.log(chalk_1.default.gray('  DevTools Bridge: ') + (capabilityStatus.devtoolsBridge.ok ? chalk_1.default.green('Reachable') : chalk_1.default.gray('Not running')));
+        // DevTools Bridge — local service, not required
+        console.log(chalk_1.default.gray('  DevTools Bridge: ') + (capabilityStatus.devtoolsBridge.ok ? chalk_1.default.green('Reachable') : chalk_1.default.gray('Not running (optional)')));
         if (capabilityStatus.devtoolsBridge.error) {
             console.log(chalk_1.default.gray('    Error: ') + chalk_1.default.gray(capabilityStatus.devtoolsBridge.error));
         }
+        // Auth scope summary — use a real server-side probe for Model Auth
+        const tokenValidation = await this.api.validateToken();
+        console.log();
+        console.log(chalk_1.default.white('Auth Scopes:'));
+        console.log(chalk_1.default.gray('  Model Auth: ') + (tokenValidation.valid ? chalk_1.default.green('Valid') : chalk_1.default.red('Invalid')) + chalk_1.default.gray(' (used by chat, agent, review, explain, generate, fix)'));
+        if (!tokenValidation.valid && tokenValidation.error) {
+            console.log(chalk_1.default.gray('    ') + chalk_1.default.red(tokenValidation.error));
+        }
+        console.log(chalk_1.default.gray('  Repo Auth: ') + (capabilityStatus.repoMemory.ok ? chalk_1.default.green('Active') : chalk_1.default.yellow('Inactive')) + chalk_1.default.gray(' (used by repo push/pull/list only)'));
+        console.log(chalk_1.default.gray('  Bridge Auth: ') + (capabilityStatus.devtoolsBridge.ok ? chalk_1.default.green('Connected') : chalk_1.default.gray('N/A')) + chalk_1.default.gray(' (used by --bridge flag only)'));
         console.log();
     }
     printLoginSuccess() {

package/dist/commands/chat.js

@@ -846,7 +846,8 @@ class ChatCommand {
             if (spinner) {
                 spinner.stop();
             }
-            const errorMsg = error.message || 'Operator workflow failed with an unknown error.';
+            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
+            const errorMsg = (0, api_js_1.formatCLIError)(cliErr);
             if (!this.jsonOutput) {
                 this.logger.error('Operator workflow failed');
             }
@@ -857,6 +858,7 @@ class ChatCommand {
                     mode: 'operator',
                     content: '',
                     error: errorMsg,
+                    errorCategory: cliErr.category,
                 }, null, 2));
             }
             else {
@@ -924,9 +926,8 @@ class ChatCommand {
         catch (error) {
             if (spinner)
                 spinner.stop();
-            if (!this.jsonOutput)
-                this.logger.error('Failed to get response');
-            const errorMsg = error.message;
+            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
+            const errorMsg = (0, api_js_1.formatCLIError)(cliErr);
             if (this.jsonOutput) {
                 process.exitCode = 1;
                 console.log(JSON.stringify({
@@ -935,6 +936,7 @@ class ChatCommand {
                     model: this.currentModel,
                     content: '',
                     error: errorMsg,
+                    errorCategory: cliErr.category,
                 }, null, 2));
             }
             else {
@@ -1046,8 +1048,8 @@ class ChatCommand {
             catch (error) {
                 if (spinner)
                     spinner.stop();
-                if (!this.jsonOutput)
-                    this.logger.error('Agent request failed');
+                const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
+                const errorMsg = (0, api_js_1.formatCLIError)(cliErr);
                 if (this.jsonOutput) {
                     process.exitCode = 1;
                     console.log(JSON.stringify({
@@ -1056,13 +1058,16 @@ class ChatCommand {
                         model: this.currentModel,
                         partial: false,
                         content: '',
-                        error: error.message,
+                        error: errorMsg,
+                        errorCategory: cliErr.category,
                         metadata: {
                             executionPath: 'local-agent-loop',
                         },
                     }, null, 2));
                 }
-                this.logger.error(error.message);
+                else {
+                    this.logger.error(errorMsg);
+                }
                 return;
             }
         }

package/dist/commands/edit.js

@@ -29,6 +29,12 @@ class EditCommand {
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Read file
         const file = this.fileUtils.readFile(filePath);
         if (!file) {
@@ -46,6 +52,11 @@ class EditCommand {
                 this.logger.error('The --apply flag requires --instruction. Example: vigthoria edit file.ts --apply --instruction "fix the bug"');
                 return;
             }
+            // Non-TTY stdin cannot prompt interactively
+            if (!process.stdin.isTTY) {
+                this.logger.error('No --instruction provided and stdin is not interactive. Use: vigthoria edit file.ts --instruction "..."');
+                return;
+            }
             const answer = await inquirer_1.default.prompt([
                 {
                     type: 'input',
@@ -93,11 +104,14 @@ Return the complete modified file content:`,
             ], options.model);
             spinner.stop();
             // Extract code from response
-            const modifiedCode = this.extractCode(response.message, file.language);
+            let modifiedCode = this.extractCode(response.message, file.language);
             if (!modifiedCode) {
                 this.logger.error('Failed to generate valid code changes');
                 return;
             }
+            // Always deduplicate — extractCode only dedupes on the no-fence
+            // fallback path, so fenced responses (the common case) need this.
+            modifiedCode = this.deduplicateCode(modifiedCode);
             // Show diff and apply
             if (options.apply) {
                 await this.applyFix(file.path, file.content, modifiedCode);
@@ -108,7 +122,8 @@ Return the complete modified file content:`,
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Edit failed:', error.message);
+            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
+            this.logger.error((0, api_js_1.formatCLIError)(cliErr));
         }
     }
     async fix(filePath, options) {
@@ -117,6 +132,12 @@ Return the complete modified file content:`,
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Read file
         const file = this.fileUtils.readFile(filePath);
         if (!file) {
@@ -173,7 +194,8 @@ Return the complete modified file content:`,
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Fix failed:', error.message);
+            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
+            this.logger.error((0, api_js_1.formatCLIError)(cliErr));
         }
     }
     extractCode(response, language) {
@@ -216,15 +238,45 @@ Return the complete modified file content:`,
         const len = lines.length;
         if (len < 4)
             return code;
-        // Pass 1: Remove adjacent duplicate non-empty lines (model stutter)
+        // Pass 1: Remove model stutter — consecutive runs of 3+ identical
+        // non-empty lines are collapsed to one.  A pair (exactly 2) is only
+        // collapsed when it occurs at the very end of the output (trailing
+        // stutter).  Pairs in the middle are kept — they may be intentional
+        // (e.g. repeated data rows, CSS rules).
         const deduped = [];
-        for (let i = 0; i < lines.length; i++) {
+        let i = 0;
+        while (i < lines.length) {
             const trimmed = lines[i].trim();
-            const prevTrimmed = deduped.length > 0 ? deduped[deduped.length - 1].trim() : null;
-            if (trimmed && trimmed === prevTrimmed) {
-                continue; // skip consecutive duplicate
+            if (!trimmed) {
+                deduped.push(lines[i]);
+                i++;
+                continue;
+            }
+            // Count the run length of identical consecutive lines
+            let runEnd = i + 1;
+            while (runEnd < lines.length && lines[runEnd].trim() === trimmed) {
+                runEnd++;
             }
-            deduped.push(lines[i]);
+            const runLen = runEnd - i;
+            // Check if this run is "effectively at end" — only trailing empty
+            // lines follow the duplicate pair.
+            const isAtEffectiveEnd = runEnd === lines.length
+                || lines.slice(runEnd).every(l => l.trim() === '');
+            if (runLen >= 3) {
+                // 3+ identical lines is almost certainly stutter — keep one
+                deduped.push(lines[i]);
+            }
+            else if (runLen === 2 && isAtEffectiveEnd) {
+                // Exactly 2 identical lines at the very end — trailing stutter
+                deduped.push(lines[i]);
+            }
+            else {
+                // 1 line, or a pair in the middle — keep all
+                for (let j = i; j < runEnd; j++) {
+                    deduped.push(lines[j]);
+                }
+            }
+            i = runEnd;
         }
         if (deduped.length < lines.length) {
             return deduped.join('\n');
@@ -269,6 +321,11 @@ Return the complete modified file content:`,
             await this.applyFix(filePath, original, modified);
             return;
         }
+        // Non-TTY: show the diff but don't try to prompt — re-run with --apply
+        if (!process.stdin.isTTY) {
+            this.logger.info('Non-interactive mode. Re-run with --apply to apply changes.');
+            return;
+        }
         const { action } = await inquirer_1.default.prompt([
             {
                 type: 'list',

package/dist/commands/explain.js

@@ -33,6 +33,12 @@ class ExplainCommand {
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Read file
         const file = this.fileUtils.readFile(filePath);
         if (!file) {
@@ -75,7 +81,8 @@ class ExplainCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Explanation failed:', error.message);
+            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
+            this.logger.error((0, api_js_1.formatCLIError)(cliErr));
         }
     }
     formatExplanation(explanation, detail) {

package/dist/commands/generate.js

@@ -31,6 +31,12 @@ class GenerateCommand {
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Determine mode
         const proMode = options.pro === true;
         // Auto-detect language from description if not explicitly specified
@@ -105,7 +111,8 @@ class GenerateCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Generation failed:', error.message);
+            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
+            this.logger.error((0, api_js_1.formatCLIError)(cliErr));
         }
     }
     /**

package/dist/commands/review.js

@@ -33,6 +33,12 @@ class ReviewCommand {
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Read file
         const file = this.fileUtils.readFile(filePath);
         if (!file) {
@@ -65,7 +71,8 @@ class ReviewCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Review failed:', error.message);
+            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
+            this.logger.error((0, api_js_1.formatCLIError)(cliErr));
         }
     }
     printTextReview(review) {

package/dist/utils/api.d.ts

@@ -4,6 +4,21 @@
  */
 import { Config } from './config.js';
 import { Logger } from './logger.js';
+export type CLIErrorCategory = 'auth' | 'repo_session' | 'model_backend' | 'bridge' | 'network' | 'timeout' | 'parsing' | 'tool_execution';
+export declare class CLIError extends Error {
+    category: CLIErrorCategory;
+    statusCode?: number;
+    endpoint?: string;
+    constructor(message: string, category: CLIErrorCategory, opts?: {
+        statusCode?: number;
+        endpoint?: string;
+        cause?: Error;
+    });
+}
+/** Classify an axios or fetch error into a structured CLIError. */
+export declare function classifyError(error: unknown, fallbackCategory?: CLIErrorCategory): CLIError;
+/** Format a CLIError for user-facing display. */
+export declare function formatCLIError(err: CLIError): string;
 export interface ChatMessage {
     role: 'user' | 'assistant' | 'system';
     content: string;
@@ -186,6 +201,17 @@ export declare class APIClient {
     private refreshToken;
     getSubscriptionStatus(): Promise<void>;
     private getAccessToken;
+    /**
+     * Validate the current auth token against the Coder API.
+     * Returns { valid: true } when the server accepts the token,
+     * { valid: false, error } when the token is rejected (401/403),
+     * and { valid: true } when the server is unreachable (network error)
+     * so that offline/degraded scenarios don't block the user.
+     */
+    validateToken(): Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
     getV3AgentBaseUrls(preferLocal?: boolean): string[];
     getV3AgentRunUrl(baseUrl: string): string;
     getV3AgentContinueUrl(baseUrl: string): string;
@@ -395,6 +421,18 @@ export declare class APIClient {
      * Returns a human-readable description of obvious errors, or empty string.
      */
     private detectSyntaxErrors;
+    /**
+     * Strip comment lines that the model added during a fix but were not
+     * present in the original code.  Used for syntax-only fixes where the
+     * model tends to annotate its changes with "// Fixed ..." comments.
+     */
+    private stripInjectedComments;
+    /**
+     * Ensure the fixed code hasn't lost closing delimiters relative to the
+     * original.  Counts {, }, (, ), [, ] outside strings/comments and if
+     * the fix has fewer closers than the original, appends the missing ones.
+     */
+    private repairBracketBalance;
     private resolveModelId;
     private getCoderHealth;
     private getModelsHealth;

package/dist/utils/api.js

@@ -7,7 +7,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APIClient = void 0;
+exports.APIClient = exports.CLIError = void 0;
+exports.classifyError = classifyError;
+exports.formatCLIError = formatCLIError;
 const axios_1 = __importDefault(require("axios"));
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
@@ -15,6 +17,77 @@ const https_1 = __importDefault(require("https"));
 const net_1 = __importDefault(require("net"));
 const path_1 = __importDefault(require("path"));
 const ws_1 = __importDefault(require("ws"));
+class CLIError extends Error {
+    category;
+    statusCode;
+    endpoint;
+    constructor(message, category, opts) {
+        super(message);
+        this.name = 'CLIError';
+        this.category = category;
+        this.statusCode = opts?.statusCode;
+        this.endpoint = opts?.endpoint;
+        if (opts?.cause)
+            this.cause = opts.cause;
+    }
+}
+exports.CLIError = CLIError;
+/** Classify an axios or fetch error into a structured CLIError. */
+function classifyError(error, fallbackCategory = 'network') {
+    if (error instanceof CLIError)
+        return error;
+    const axErr = error;
+    const status = axErr?.response?.status;
+    const endpoint = axErr?.config?.url || axErr?.config?.baseURL || '';
+    const message = axErr?.response?.data
+        ? typeof axErr.response.data.error === 'string'
+            ? axErr.response.data.error
+            : typeof axErr.response.data.message === 'string'
+                ? axErr.response.data.message
+                : error.message
+        : error.message || String(error);
+    if (status === 401 || status === 403) {
+        // Distinguish repo/community auth from model auth
+        if (/community|repo/i.test(endpoint)) {
+            return new CLIError(message, 'repo_session', { statusCode: status, endpoint });
+        }
+        return new CLIError(message, 'auth', { statusCode: status, endpoint });
+    }
+    if (status && status >= 500) {
+        return new CLIError(message, 'model_backend', { statusCode: status, endpoint });
+    }
+    if (/timeout|ETIMEDOUT|ESOCKETTIMEDOUT|aborted/i.test(message)) {
+        return new CLIError(message, 'timeout', { endpoint });
+    }
+    if (/ECONNREFUSED|ENOTFOUND|ENETUNREACH|EAI_AGAIN|fetch failed/i.test(message)) {
+        return new CLIError(message, 'network', { endpoint });
+    }
+    return new CLIError(message, fallbackCategory, { statusCode: status, endpoint, cause: error instanceof Error ? error : undefined });
+}
+/** Format a CLIError for user-facing display. */
+function formatCLIError(err) {
+    const tag = `[${err.category}]`;
+    switch (err.category) {
+        case 'auth':
+            return `${tag} Authentication failed${err.statusCode ? ` (${err.statusCode})` : ''}. Run: vigthoria login`;
+        case 'repo_session':
+            return `${tag} Repository session expired or missing${err.statusCode ? ` (${err.statusCode})` : ''}. This does not affect AI commands. Re-authenticate repo with: vigthoria repo list`;
+        case 'model_backend':
+            return `${tag} Model backend error${err.statusCode ? ` (${err.statusCode})` : ''}: ${err.message}`;
+        case 'bridge':
+            return `${tag} Bridge connection error: ${err.message}`;
+        case 'network':
+            return `${tag} Network error: ${err.message}. Check your internet connection.`;
+        case 'timeout':
+            return `${tag} Request timed out: ${err.message}`;
+        case 'parsing':
+            return `${tag} Response parsing error: ${err.message}`;
+        case 'tool_execution':
+            return `${tag} Tool execution error: ${err.message}`;
+        default:
+            return `${tag} ${err.message}`;
+    }
+}
 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);
@@ -26,9 +99,9 @@ const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
     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 || '3900000';
+    const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS || '300000';
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 3900000;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
 })();
 class APIClient {
     client;
@@ -102,16 +175,24 @@ class APIClient {
             }
             return req;
         });
-        // Add response interceptor for token refresh
-        this.client.interceptors.response.use((res) => res, async (error) => {
-            if (error.response?.status === 401) {
-                const refreshed = await this.refreshToken();
-                if (refreshed && error.config) {
-                    return this.client.request(error.config);
+        // Add response interceptors for token refresh + structured errors
+        const createAuthRetryInterceptor = (client) => {
+            client.interceptors.response.use((res) => res, async (error) => {
+                if (error.response?.status === 401) {
+                    const refreshed = await this.refreshToken();
+                    if (refreshed && error.config) {
+                        return client.request(error.config);
+                    }
+                    throw classifyError(error, 'auth');
                 }
-            }
-            throw error;
-        });
+                throw classifyError(error);
+            });
+        };
+        createAuthRetryInterceptor(this.client);
+        createAuthRetryInterceptor(this.modelRouterClient);
+        if (this.selfHostedModelRouterClient) {
+            createAuthRetryInterceptor(this.selfHostedModelRouterClient);
+        }
     }
     getSelfHostedModelsApiUrl() {
         const configuredUrl = process.env.VIGTHORIA_SELF_HOSTED_MODELS_API_URL
@@ -259,6 +340,34 @@ class APIClient {
             || this.config.get('authToken')
             || null;
     }
+    /**
+     * Validate the current auth token against the Coder API.
+     * Returns { valid: true } when the server accepts the token,
+     * { valid: false, error } when the token is rejected (401/403),
+     * and { valid: true } when the server is unreachable (network error)
+     * so that offline/degraded scenarios don't block the user.
+     */
+    async validateToken() {
+        const token = this.getAccessToken();
+        if (!token) {
+            return { valid: false, error: 'No auth token configured. Run: vigthoria login' };
+        }
+        try {
+            await this.client.get('/api/user/profile', { timeout: 10000 });
+            return { valid: true };
+        }
+        catch (error) {
+            if (error instanceof CLIError && error.category === 'auth') {
+                return { valid: false, error: 'Auth token expired or invalid. Run: vigthoria login' };
+            }
+            const axErr = error;
+            if (axErr.response?.status === 401 || axErr.response?.status === 403) {
+                return { valid: false, error: 'Auth token expired or invalid. Run: vigthoria login' };
+            }
+            // Network/timeout errors — don't assume token is bad
+            return { valid: true };
+        }
+    }
     getV3AgentBaseUrls(preferLocal = false) {
         const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
         const allowLocalV3Agent = process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1' || preferLocal;
@@ -2932,13 +3041,18 @@ document.addEventListener('DOMContentLoaded', () => {
                 };
             }
             catch (error) {
+                const isAbort = error?.name === 'AbortError' || error?.code === 'ABORT_ERR';
+                if (isAbort) {
+                    const mins = Math.round(timeoutMs / 60000);
+                    throw new CLIError(`Operator workflow timed out after ${mins} minute(s). You can increase the timeout with VIGTHORIA_OPERATOR_TIMEOUT_MS.`, 'timeout', error);
+                }
                 errors.push(`${baseUrl}: ${error?.message || String(error)}`);
             }
             finally {
                 clearTimeout(timeoutId);
             }
         }
-        throw new Error(errors.join(' | '));
+        throw new CLIError(`Operator workflow failed on all endpoints: ${errors.join(' | ')}`, 'model_backend');
     }
     /**
      * Chat API - Direct Vigthoria Models API Architecture
@@ -2970,7 +3084,7 @@ document.addEventListener('DOMContentLoaded', () => {
             }
         }
         // No more localhost fallbacks - CLI is for external users!
-        throw new Error('AI service unavailable. Please check your internet connection or try again later.');
+        throw new CLIError('AI service unavailable. Please check your internet connection or try again later.', 'model_backend');
     }
     shouldSkipCloudRoutes(resolvedModel) {
         return this.shouldSimulateCloudFailure() && this.isCloudModelId(resolvedModel);
@@ -3602,9 +3716,19 @@ document.addEventListener('DOMContentLoaded', () => {
             .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// IMPORTANT: Fix ONLY these specific bugs. Do not add comments, do not restructure the code, do not add or remove lines beyond the minimal fix.\n\n${code}`
-            : code;
+        // Build a constraint preamble that's stricter for syntax-only mode.
+        let preamble;
+        if (fixType === 'syntax') {
+            preamble = allHints
+                ? `// SYNTAX ERRORS DETECTED BY CLIENT:\n// ${allHints}\n// RULES: Fix ONLY bracket/parenthesis/brace mismatches and keyword typos. Do NOT rename functions, do NOT add comments, do NOT restructure or reformat. Output the corrected code ONLY.\n\n`
+                : '';
+        }
+        else {
+            preamble = allHints
+                ? `// BUGS DETECTED BY STATIC ANALYSIS — YOU MUST FIX THESE:\n// ${allHints}\n// IMPORTANT: Fix ONLY these specific bugs. Do not add comments, do not restructure the code, do not add or remove lines beyond the minimal fix.\n\n`
+                : '';
+        }
+        const augmentedCode = preamble ? `${preamble}${code}` : code;
         const response = await this.client.post('/api/ai/fix', {
             code: augmentedCode,
             language,
@@ -3616,16 +3740,27 @@ document.addEventListener('DOMContentLoaded', () => {
         // 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 && allHints && fixed === augmentedCode) {
+        if (changes.length === 0 && preamble && fixed === augmentedCode) {
             fixed = code; // restore original
         }
         // Strip the injected comment block if it leaked into the output
-        if (fixed.startsWith('// BUGS DETECTED BY STATIC ANALYSIS') || 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);
             }
         }
+        // For syntax-only fixes, strip any comments the model added that
+        // weren't in the original code (e.g. "// Fixed mismatched parentheses").
+        if (fixType === 'syntax' && fixed !== code) {
+            fixed = this.stripInjectedComments(code, fixed, language);
+        }
+        // Safety net: for syntax fixes, ensure the fix didn't make bracket
+        // balance worse.  If the original had more closing delimiters than
+        // the fix, append the missing ones.
+        if (fixType === 'syntax' && fixed !== code) {
+            fixed = this.repairBracketBalance(code, fixed);
+        }
         // If there are still no changes but the fixed code differs, compute
         // a semantic diff using LCS so inserted/removed lines don't cause
         // every subsequent line to appear as changed.
@@ -3806,6 +3941,125 @@ document.addEventListener('DOMContentLoaded', () => {
         }
         return errors.join('; ');
     }
+    /**
+     * Strip comment lines that the model added during a fix but were not
+     * present in the original code.  Used for syntax-only fixes where the
+     * model tends to annotate its changes with "// Fixed ..." comments.
+     */
+    stripInjectedComments(original, fixed, language) {
+        const lang = language.toLowerCase();
+        // Only handle JS/TS/Python single-line comment patterns for now
+        let wholeLineRe;
+        let inlineRe;
+        if (lang === 'python' || lang === 'py') {
+            wholeLineRe = /^\s*#\s/;
+            inlineRe = /\s+#\s.*$/;
+        }
+        else {
+            wholeLineRe = /^\s*\/\/\s/;
+            inlineRe = /\s+\/\/\s.*$/;
+        }
+        const origLines = original.split('\n');
+        const origSet = new Set(origLines.map(l => l.trim()));
+        const fixedLines = fixed.split('\n');
+        const result = [];
+        for (let idx = 0; idx < fixedLines.length; idx++) {
+            let line = fixedLines[idx];
+            // Remove whole-line comments not in original
+            if (wholeLineRe.test(line) && !origSet.has(line.trim())) {
+                continue;
+            }
+            // Strip inline trailing comments the model added.
+            // Only strip if the corresponding original line at the same position
+            // didn't have an inline comment at all.
+            if (inlineRe.test(line)) {
+                const origLine = idx < origLines.length ? origLines[idx] : '';
+                if (!inlineRe.test(origLine)) {
+                    line = line.replace(inlineRe, '');
+                }
+            }
+            result.push(line);
+        }
+        return result.join('\n');
+    }
+    /**
+     * Ensure the fixed code hasn't lost closing delimiters relative to the
+     * original.  Counts {, }, (, ), [, ] outside strings/comments and if
+     * the fix has fewer closers than the original, appends the missing ones.
+     */
+    repairBracketBalance(original, fixed) {
+        const count = (src) => {
+            let braces = 0, parens = 0, brackets = 0;
+            let inStr = null;
+            let inLine = false, inBlock = false;
+            for (let i = 0; i < src.length; i++) {
+                const ch = src[i], nx = src[i + 1] || '';
+                if (inLine) {
+                    if (ch === '\n')
+                        inLine = false;
+                    continue;
+                }
+                if (inBlock) {
+                    if (ch === '*' && nx === '/') {
+                        inBlock = false;
+                        i++;
+                    }
+                    continue;
+                }
+                if (inStr) {
+                    if (ch === inStr && src[i - 1] !== '\\')
+                        inStr = null;
+                    continue;
+                }
+                if (ch === '/' && nx === '/') {
+                    inLine = true;
+                    continue;
+                }
+                if (ch === '/' && nx === '*') {
+                    inBlock = true;
+                    continue;
+                }
+                if (ch === '"' || ch === "'" || ch === '`') {
+                    inStr = ch;
+                    continue;
+                }
+                if (ch === '{')
+                    braces++;
+                else if (ch === '}')
+                    braces--;
+                else if (ch === '(')
+                    parens++;
+                else if (ch === ')')
+                    parens--;
+                else if (ch === '[')
+                    brackets++;
+                else if (ch === ']')
+                    brackets--;
+            }
+            return { braces, parens, brackets };
+        };
+        const orig = count(original);
+        const fix = count(fixed);
+        const append = [];
+        // If original was balanced (or close) but fix is missing closers,
+        // append them.  Only act when the fix is *more unbalanced* than original.
+        if (fix.braces > orig.braces) {
+            for (let i = 0; i < fix.braces - orig.braces; i++)
+                append.push('}');
+        }
+        if (fix.parens > orig.parens) {
+            for (let i = 0; i < fix.parens - orig.parens; i++)
+                append.push(')');
+        }
+        if (fix.brackets > orig.brackets) {
+            for (let i = 0; i < fix.brackets - orig.brackets; i++)
+                append.push(']');
+        }
+        if (append.length > 0) {
+            return fixed.trimEnd() + '\n' + append.join('\n');
+        }
+        return fixed;
+    }
     // Model resolution - maps Vigthoria model names to internal IDs
     // INTERNAL USE ONLY - users see only Vigthoria branding
     resolveModelId(shortName) {

package/dist/utils/logger.js

@@ -24,7 +24,12 @@ const ora_1 = __importDefault(require("ora"));
  */
 function createSpinner(textOrOpts) {
     const opts = typeof textOrOpts === 'string' ? { text: textOrOpts } : textOrOpts;
-    return (0, ora_1.default)({ ...opts, stream: process.stderr });
+    // Suppress spinner animation when stderr is not a TTY (piped output,
+    // CI, non-interactive terminals).  The spinner object still works — its
+    // .start()/.stop()/.succeed() methods are no-ops — so callers don't
+    // need conditional logic.
+    const isSilent = !process.stderr.isTTY;
+    return (0, ora_1.default)({ ...opts, stream: process.stderr, isSilent });
 }
 class Logger {
     verbose = false;

package/package.json

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