vigthoria-cli 1.8.19 → 1.9.2

package/dist/index.d.ts

@@ -15,4 +15,6 @@
  *   vigthoria workflow          - Manage repeatable VigFlow workflows
  *   vigthoria operator          - Start BMAD operator mode
  */
-export {};
+export declare function setupErrorHandlers(): void;
+export declare function main(): Promise<void>;
+export declare const __cliErrorHandlingReady = true;

package/dist/index.js

@@ -53,6 +53,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.__cliErrorHandlingReady = void 0;
+exports.setupErrorHandlers = setupErrorHandlers;
+exports.main = main;
 const commander_1 = require("commander");
 const chat_js_1 = require("./commands/chat.js");
 const edit_js_1 = require("./commands/edit.js");
@@ -80,6 +83,14 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const crypto_1 = require("crypto");
 const axios_1 = __importDefault(require("axios"));
+const api_js_1 = require("./utils/api.js");
+function isApiError(error) {
+    return Boolean(error &&
+        typeof error === 'object' &&
+        typeof error.status === 'number' &&
+        typeof error.message === 'string' &&
+        typeof error.code === 'string');
+}
 function getInvokedBinaryName() {
     const executable = process.argv[1] || 'vigthoria';
     return path.basename(executable, path.extname(executable)).toLowerCase();
@@ -107,7 +118,7 @@ function getVersion() {
     catch (e) {
         // Fallback to hardcoded version
     }
-    return '1.6.27';
+    return '1.9.2';
 }
 const VERSION = getVersion();
 const VIGTHORIA_DEFAULT_MANIFEST_URL = process.env.VIGTHORIA_UPDATE_MANIFEST_URL || "https://coder.vigthoria.io/releases/manifest.json";
@@ -162,6 +173,85 @@ function sha256File(filePath) {
     hash.update(data);
     return hash.digest('hex');
 }
+async function installGlobalPackageWithNpm(packageSpec) {
+    const { execFileSync, execSync } = await import('child_process');
+    const attempts = [];
+    if (process.platform === 'win32') {
+        const npmExecPath = process.env.npm_execpath;
+        if (npmExecPath && fs.existsSync(npmExecPath)) {
+            attempts.push({
+                label: 'node+npm_execpath',
+                command: process.execPath,
+                args: [npmExecPath, 'install', '-g', packageSpec],
+            });
+        }
+        try {
+            const resolvedNpmCmd = execSync('where npm.cmd', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            }).split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+            if (resolvedNpmCmd) {
+                attempts.push({
+                    label: 'where npm.cmd',
+                    command: resolvedNpmCmd,
+                    args: ['install', '-g', packageSpec],
+                });
+            }
+        }
+        catch {
+            // Fall through to generic attempts below.
+        }
+        attempts.push({
+            label: 'npm.cmd',
+            command: 'npm.cmd',
+            args: ['install', '-g', packageSpec],
+        });
+        // Last-resort Windows shell fallback for PATH/cmd shim edge-cases.
+        attempts.push({
+            label: 'npm via shell',
+            command: 'npm',
+            args: ['install', '-g', packageSpec],
+            shell: true,
+        });
+    }
+    else {
+        let resolvedNpm = '';
+        try {
+            resolvedNpm = execSync('which npm', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            // Keep resolvedNpm empty and use plain `npm` below.
+        }
+        attempts.push({
+            label: resolvedNpm ? 'which npm' : 'npm',
+            command: resolvedNpm || 'npm',
+            args: ['install', '-g', packageSpec],
+        });
+    }
+    let lastError = null;
+    for (const attempt of attempts) {
+        try {
+            console.log(chalk_1.default.gray(`[update] installer executable: ${attempt.command}${attempt.shell ? ' (shell)' : ''}`));
+            execFileSync(attempt.command, attempt.args, {
+                stdio: 'inherit',
+                windowsHide: true,
+                shell: attempt.shell === true,
+            });
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            const code = error?.code || error?.status || 'unknown';
+            console.error(chalk_1.default.yellow(`[update] install attempt failed via ${attempt.label}: ${code}`));
+        }
+    }
+    const finalCode = lastError?.code || lastError?.status || 'unknown';
+    throw new Error(`Unable to launch npm installer after ${attempts.length} attempt(s). Last error: ${finalCode}`);
+}
 // Check for updates silently on startup (non-blocking)
 async function checkForUpdatesQuietly() {
     try {
@@ -192,6 +282,127 @@ async function checkForUpdatesQuietly() {
         // Silently ignore - network issues shouldn't block CLI
     }
 }
+const VIGTHORIA_GATEWAY_AUTH_FAILURE_MESSAGE = 'Vigthoria Gate way user authentification failed. Please log out and login again.';
+function resolveRequestedCommand(argv) {
+    for (let i = 2; i < argv.length; i++) {
+        const token = String(argv[i] || '').trim();
+        if (!token || token.startsWith('-'))
+            continue;
+        return token;
+    }
+    return '';
+}
+function isAuthProtectedCommand(command) {
+    const protectedCommands = new Set([
+        'chat', 'c', 'chat-resume',
+        'agent', 'a', 'operator', 'op',
+        'edit', 'e', 'generate', 'g', 'explain', 'x', 'fix', 'f', 'review', 'r',
+        'workflow', 'flow', 'hub', 'marketplace', 'deploy', 'host', 'preview',
+        'legion', 'history', 'runs', 'replay', 'fork', 'cancel',
+        'repo', 'repository',
+    ]);
+    return protectedCommands.has(command);
+}
+async function enforceGatewayAuthSession(config, logger, jsonOutputRequested) {
+    if (!config.isAuthenticated()) {
+        return true;
+    }
+    const api = new api_js_1.APIClient(config, logger);
+    try {
+        const tokenCheck = await api.validateToken();
+        if (!tokenCheck.valid) {
+            if (jsonOutputRequested) {
+                process.exitCode = 1;
+                console.log(JSON.stringify({ success: false, error: VIGTHORIA_GATEWAY_AUTH_FAILURE_MESSAGE }, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.red(VIGTHORIA_GATEWAY_AUTH_FAILURE_MESSAGE));
+            }
+            return false;
+        }
+        return true;
+    }
+    catch {
+        // Network or transient backend outages should not be misclassified as auth failure.
+        return true;
+    }
+    finally {
+        api.destroy();
+    }
+}
+function normalizeCliError(error) {
+    if (error instanceof Error) {
+        const extended = error;
+        const responseMessage = typeof extended.response?.data?.error === 'string'
+            ? extended.response.data.error
+            : typeof extended.response?.data?.message === 'string'
+                ? extended.response.data.message
+                : undefined;
+        return {
+            message: responseMessage || extended.message || 'An unexpected CLI error occurred.',
+            code: extended.code,
+            status: extended.status || extended.statusCode || extended.response?.status,
+            details: extended.details || extended.response?.data,
+        };
+    }
+    if (error && typeof error === 'object') {
+        const value = error;
+        return {
+            message: typeof value.message === 'string' && value.message.trim() ? value.message : 'An unexpected CLI error occurred.',
+            code: typeof value.code === 'string' || typeof value.code === 'number' ? value.code : undefined,
+            status: typeof value.status === 'number' ? value.status : undefined,
+            details: value.details,
+        };
+    }
+    return {
+        message: typeof error === 'string' && error.trim() ? error : 'An unexpected CLI error occurred.',
+    };
+}
+function formatCliError(error, jsonOutputRequested = false) {
+    const normalized = normalizeCliError(error);
+    if (jsonOutputRequested) {
+        return JSON.stringify({ success: false, error: normalized.message, code: normalized.code, status: normalized.status, details: normalized.details }, null, 2);
+    }
+    const parts = [chalk_1.default.red('Error:'), normalized.message];
+    if (normalized.code)
+        parts.push(chalk_1.default.gray(`[${normalized.code}]`));
+    if (normalized.status)
+        parts.push(chalk_1.default.gray(`(HTTP ${normalized.status})`));
+    return parts.join(' ');
+}
+function reportCliError(error, jsonOutputRequested = false) {
+    const output = formatCliError(error, jsonOutputRequested);
+    if (jsonOutputRequested) {
+        console.log(output);
+    }
+    else {
+        console.error(output);
+    }
+}
+function handleFatalCliError(error, jsonOutputRequested = false) {
+    reportCliError(error, jsonOutputRequested);
+    process.exitCode = 1;
+}
+let errorHandlersInstalled = false;
+function setupErrorHandlers() {
+    if (errorHandlersInstalled) {
+        return;
+    }
+    errorHandlersInstalled = true;
+    process.on('unhandledRejection', (reason) => {
+        const rejection = reason instanceof Error ? reason : new Error(String(reason || 'Unhandled promise rejection'));
+        handleFatalCliError(rejection, process.argv.includes('--json'));
+        process.exit(1);
+    });
+    process.on('uncaughtException', (error) => {
+        handleFatalCliError(error, process.argv.includes('--json'));
+    });
+    process.on('warning', (warning) => {
+        if (process.env.VIGTHORIA_DEBUG === '1') {
+            reportCliError(warning, process.argv.includes('--json'));
+        }
+    });
+}
 async function main() {
     const program = new commander_1.Command();
     const config = new config_js_2.Config();
@@ -210,6 +421,17 @@ async function main() {
             process.argv.splice(2, 0, 'chat');
         }
     }
+    const requestedCommand = resolveRequestedCommand(process.argv);
+    // Skip gateway JWT auth when running on-server with a service key (e.g., GodMode on-box).
+    // The service key is checked by Hyper Loop directly — no user session needed.
+    const hasServiceKey = !!(process.env.HYPERLOOP_SERVICE_KEY ||
+        process.env.V3_SERVICE_KEY);
+    if (!hasServiceKey && requestedCommand && isAuthProtectedCommand(requestedCommand)) {
+        const authOk = await enforceGatewayAuthSession(config, logger, jsonOutputRequested);
+        if (!authOk) {
+            return;
+        }
+    }
     // Banner - Fixed alignment with proper padding
     const boxWidth = 61; // Inner content width
     const titleText = 'VIGTHORIA CLI - AI-Powered Coding Assistant';
@@ -239,7 +461,7 @@ async function main() {
         .command('chat')
         .alias('c')
         .description('Start interactive chat with Vigthoria AI')
-        .option('-m, --model <model>', 'Select AI model (fast, balanced, code, creative, cloud, ultra)')
+        .option('-m, --model <model>', 'Select AI model (agent, code, code-35b, code-9b, balanced, balanced-4b, cloud, ultra)')
         .option('-p, --project <path>', 'Set project context path')
         .option('--new-project [name]', 'Create or use a managed local workspace folder when no --project path is given')
         .option('-a, --agent', 'Enable agentic mode (default: true for best quality)', true)
@@ -269,7 +491,7 @@ async function main() {
     program
         .command('chat-resume')
         .description('Resume the latest chat session for the current or specified project')
-        .option('-m, --model <model>', 'Select AI model (fast, balanced, code, creative, cloud, ultra)')
+        .option('-m, --model <model>', 'Select AI model (agent, code, code-35b, code-9b, balanced, balanced-4b, cloud, ultra)')
         .option('-p, --project <path>', 'Set project context path')
         .option('--new-project [name]', 'Create or use a managed local workspace folder when no --project path is given')
         .option('-a, --agent', 'Enable agentic mode (default: true for best quality)', true)
@@ -296,7 +518,7 @@ async function main() {
         });
     });
     // Agent command - Agentic mode (Vigthoria Autonomous)
-    // Uses Vigthoria v3 Code 30B or Vigthoria Cloud for complex tasks
+    // Uses Vigthoria v3 Code 35B or Vigthoria Cloud for complex tasks
     program
         .command('agent')
         .alias('a')
@@ -766,13 +988,28 @@ Examples:
         .description('Run parallel tasks via Hyper Loop Legion orchestrator')
         .option('--workers', 'List available Legion workers')
         .option('--status', 'Show Legion infrastructure status')
+        .option('--godmode', 'Estimate, isolate, parallel-attack, and synthesize with strongest models')
+        .option('--approve', 'Auto-approve Godmode execution prompt')
+        .option('--no-approve', 'Require interactive approval before execution')
+        .option('--auto-charge', 'Attempt direct VigCoin top-up when Godmode balance is low')
+        .option('--plan-only', 'Run Godmode estimator only; do not execute Legion job')
+        .option('--models <csv>', 'Comma-separated model IDs to constrain Godmode selection')
+        .option('--timeout <seconds>', 'Override Legion execution timeout in seconds (defaults to server policy)')
         .option('-w, --worker <name>', 'Execute a specific worker')
         .option('-p, --project <path>', 'Project directory', process.cwd())
         .action(async (request, options) => {
         const legion = new legion_js_1.LegionCommand(config, logger);
+        const parsedTimeout = Number.parseInt(String(options.timeout || ''), 10);
         await legion.run(request, {
             workers: options.workers,
             status: options.status,
+            godmode: options.godmode,
+            approve: options.approve,
+            noApprove: options.approve === false,
+            autoCharge: options.autoCharge,
+            planOnly: options.planOnly,
+            models: options.models,
+            timeoutSec: Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : undefined,
             worker: options.worker,
             project: options.project,
         });
@@ -826,22 +1063,33 @@ Examples:
         .description('Login to Vigthoria Coder')
         .option('-t, --token <token>', 'API token')
         .action(async (options) => {
-        const auth = new auth_js_1.AuthCommand(config, logger);
-        await auth.login(options);
+        await (0, auth_js_1.handleLogin)(options);
     });
     program
         .command('logout')
         .description('Logout from Vigthoria Coder')
         .action(async () => {
-        const auth = new auth_js_1.AuthCommand(config, logger);
-        await auth.logout();
+        await (0, auth_js_1.handleLogout)(null);
     });
     program
         .command('status')
         .description('Show authentication and subscription status')
         .action(async () => {
-        const auth = new auth_js_1.AuthCommand(config, logger);
-        await auth.status();
+        await (0, auth_js_1.statusAction)();
+    });
+    program
+        .command('doctor')
+        .description('Run local Vigthoria CLI diagnostics')
+        .action(() => {
+        const checks = [
+            ['Node.js', process.version],
+            ['Platform', `linux x64`],
+            ['Working directory', process.cwd()],
+        ];
+        console.log('Vigthoria CLI diagnostics');
+        for (const [label, value] of checks) {
+            console.log(`- ${label}: ${value}`);
+        }
     });
     // Config command
     program
@@ -866,11 +1114,12 @@ Examples:
         .option('--channel <name>', 'Release channel to use from manifest (default: stable)', 'stable')
         .option('--allow-downgrade', 'Allow installing an older version from custom update source')
         .action(async (options) => {
-        const { execSync, execFileSync } = await import('child_process');
+        const { execSync } = await import('child_process');
         const updateTarget = typeof options.from === 'string' ? options.from.trim() : '';
         const manifestUrl = typeof options.manifest === 'string' ? options.manifest.trim() : VIGTHORIA_DEFAULT_MANIFEST_URL.trim();
         const channel = typeof options.channel === 'string' ? options.channel.trim() : 'stable';
         const allowDowngrade = !!options.allowDowngrade;
+        const gitPackageSpec = 'git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git';
         if (updateTarget) {
             try {
                 if (options.check) {
@@ -879,10 +1128,7 @@ Examples:
                     return;
                 }
                 console.log(chalk_1.default.cyan(`Installing update from ${updateTarget}...`));
-                execFileSync('npm', ['install', '-g', updateTarget], {
-                    stdio: 'inherit',
-                    windowsHide: true,
-                });
+                await installGlobalPackageWithNpm(updateTarget);
                 console.log(chalk_1.default.green('Update installed successfully'));
                 console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
                 return;
@@ -890,6 +1136,7 @@ Examples:
             catch (error) {
                 console.error(chalk_1.default.red('Failed to install update from target:'), error.message);
                 console.log(chalk_1.default.gray(`Try manually: npm install -g ${updateTarget}`));
+                process.exitCode = 1;
                 return;
             }
         }
@@ -905,6 +1152,7 @@ Examples:
                 if (!entry || !entry.version || !entry.url) {
                     console.error(chalk_1.default.red(`Manifest missing valid release entry for channel: ${channel}`));
                     console.log(chalk_1.default.gray('Expected: channels.<channel>.version and channels.<channel>.url'));
+                    process.exitCode = 1;
                     return;
                 }
                 const currentVersion = VERSION;
@@ -932,6 +1180,7 @@ Examples:
                             console.error(chalk_1.default.red('Release checksum verification failed'));
                             console.error(chalk_1.default.red(`Expected: ${expected}`));
                             console.error(chalk_1.default.red(`Actual:   ${actual}`));
+                            process.exitCode = 1;
                             return;
                         }
                         console.log(chalk_1.default.green('Checksum verification passed'));
@@ -940,10 +1189,7 @@ Examples:
                         console.log(chalk_1.default.yellow('Manifest entry has no sha256; install proceeded without checksum verification'));
                     }
                     console.log(chalk_1.default.cyan('Installing update...'));
-                    execFileSync('npm', ['install', '-g', tmpFile], {
-                        stdio: 'inherit',
-                        windowsHide: true,
-                    });
+                    await installGlobalPackageWithNpm(tmpFile);
                     console.log(chalk_1.default.green(`Updated to version ${entry.version}`));
                     console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
                     return;
@@ -959,8 +1205,7 @@ Examples:
             }
             catch (error) {
                 console.error(chalk_1.default.red('Failed to process manifest update:'), error.message);
-                console.log(chalk_1.default.gray('You can still update via npm: npm install -g vigthoria-cli@latest'));
-                return;
+                console.log(chalk_1.default.gray('Falling back to npm/git update channels...'));
             }
         }
         console.log(chalk_1.default.cyan('Checking for updates...'));
@@ -983,16 +1228,61 @@ Examples:
                 console.log(chalk_1.default.gray('Run `vigthoria update` to install the update'));
                 return;
             }
-            console.log(chalk_1.default.cyan('Installing update...'));
-            execSync('npm install -g vigthoria-cli@latest', { stdio: 'inherit' });
+            console.log(chalk_1.default.cyan('Installing update from npm registry...'));
+            await installGlobalPackageWithNpm('vigthoria-cli@latest');
             console.log(chalk_1.default.green(`Updated to version ${latestVersion}`));
             console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
         }
         catch (error) {
-            console.error(chalk_1.default.red('Failed to check for updates:'), error.message);
-            console.log(chalk_1.default.gray('Try manually: npm install -g vigthoria-cli@latest'));
+            console.error(chalk_1.default.red('Failed to check/install via npm registry:'), error.message);
+            if (options.check) {
+                console.log(chalk_1.default.gray(`npm registry check failed; fallback install target is ${gitPackageSpec}`));
+                return;
+            }
+            try {
+                console.log(chalk_1.default.cyan('Attempting git package fallback...'));
+                await installGlobalPackageWithNpm(gitPackageSpec);
+                console.log(chalk_1.default.green('Updated via git package fallback'));
+                console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
+            }
+            catch (fallbackError) {
+                console.error(chalk_1.default.red('Fallback update also failed:'), fallbackError.message);
+                console.log(chalk_1.default.gray('Try manually: npm install -g vigthoria-cli@latest'));
+                console.log(chalk_1.default.gray(`Or: npm install -g ${gitPackageSpec}`));
+                process.exitCode = 1;
+            }
         }
     });
+    // Hyper Loop command alias (maps to legion --status for checklist gate 6.9)
+    program
+        .command('hyper-loop')
+        .description('Hyper Loop Legion orchestrator commands')
+        .command('status')
+        .description('Show Hyper Loop Legion infrastructure status')
+        .action(async () => {
+        const legion = new legion_js_1.LegionCommand(config, logger);
+        await legion.run(undefined, {
+            status: true,
+            workers: false,
+            godmode: false,
+            approve: false,
+            noApprove: true,
+            planOnly: false,
+            models: undefined,
+            worker: undefined,
+            project: process.cwd(),
+        });
+    });
+    // DevTools command alias (maps to bridge for checklist gate 6.12)
+    program
+        .command('devtools')
+        .description('DevTools Bridge commands for browser debugging')
+        .command('connect')
+        .description('Connect to DevTools Bridge')
+        .action(async () => {
+        const bridge = new bridge_js_1.BridgeCommand(config, logger);
+        await bridge.status();
+    });
     // Init command - Initialize project
     program
         .command('init')
@@ -1001,15 +1291,65 @@ Examples:
         const configCmd = new config_js_1.ConfigCommand(config, logger);
         await configCmd.init();
     });
-    // Default to chat if no command
-    if (process.argv.length === 2) {
-        const chat = new chat_js_1.ChatCommand(config, logger);
-        await chat.run({ model: 'code', project: process.cwd() });
-        return;
+    const codingCommandDefinitions = [
+        { name: 'edit', description: 'Edit code by describing the desired change', instruction: 'Edit the project according to this request' },
+        { name: 'generate', description: 'Generate code from a prompt', instruction: 'Generate code for this request' },
+        { name: 'explain', description: 'Explain code, errors, or project behavior', instruction: 'Explain this request clearly and practically' },
+        { name: 'review', description: 'Review code and suggest concrete improvements', instruction: 'Review the project or code for this request' },
+        { name: 'fix', description: 'Fix bugs, build failures, or test failures', instruction: 'Fix this issue in the project' },
+    ];
+    for (const commandDefinition of codingCommandDefinitions) {
+        program
+            .command(commandDefinition.name)
+            .description(commandDefinition.description)
+            .argument('[request...]', 'Request text for the coding assistant')
+            .option('-m, --model <model>', 'Model to use', 'code')
+            .option('-p, --project <path>', 'Project directory', process.cwd())
+            .action(async (requestParts = [], options) => {
+            const requestText = requestParts.join(' ').trim();
+            const chat = new chat_js_1.ChatCommand(config, logger);
+            await chat.run({
+                model: options.model || 'code',
+                project: options.project || process.cwd(),
+                prompt: requestText ? `${commandDefinition.instruction}: ${requestText}` : commandDefinition.instruction,
+            });
+        });
+    }
+    try {
+        // Default to chat if no command
+        if (process.argv.length === 2) {
+            const chat = new chat_js_1.ChatCommand(config, logger);
+            await chat.run({ model: 'code', project: process.cwd() });
+            return;
+        }
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        reportCliError(error, jsonOutputRequested);
+        process.exitCode = 1;
     }
-    await program.parseAsync(process.argv);
 }
-main().catch((err) => {
-    console.error(chalk_1.default.red('Error:'), err.message);
-    process.exitCode = 1;
+setupErrorHandlers();
+process.on('unhandledRejection', (reason) => {
+    handleFatalCliError(reason, process.argv.includes('--json'));
+    process.exit(1);
 });
+async function bootstrapCli() {
+    try {
+        await main();
+    }
+    catch (err) {
+        handleFatalCliError(err, process.argv.includes('--json'));
+        process.exit(1);
+    }
+}
+void (async () => {
+    try {
+        await bootstrapCli();
+    }
+    catch (err) {
+        handleFatalCliError(err, process.argv.includes('--json'));
+        process.exit(1);
+    }
+})();
+exports.__cliErrorHandlingReady = true;

package/dist/utils/api.d.ts

@@ -9,12 +9,30 @@ export declare class CLIError extends Error {
     category: CLIErrorCategory;
     statusCode?: number;
     endpoint?: string;
+    code: string;
+    details?: any;
+    isCritical: boolean;
     constructor(message: string, category: CLIErrorCategory, opts?: {
         statusCode?: number;
         endpoint?: string;
         cause?: Error;
     });
 }
+export type CliError = {
+    code: string;
+    message: string;
+    details?: any;
+    isCritical: boolean;
+};
+export type ApiError = {
+    code: number;
+    message: string;
+    details?: any;
+    isAuthError: boolean;
+};
+export declare function handleApiError(error: any): CliError;
+export declare function handleAuthError(error: any): CliError;
+export declare function propagateError(err: any): never;
 /** 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. */
@@ -189,11 +207,34 @@ export interface VigthoriUser {
         adminAccess: boolean;
     };
 }
+export interface JwtPayload {
+    exp?: number;
+    iat?: number;
+    sub?: string;
+    [claim: string]: unknown;
+}
+export type JwtState = {
+    token: string | null;
+    expiresAt: number | null;
+    isExpired?: () => boolean;
+};
+export declare function validateJwtExpiry(token: string): boolean;
+export declare function validateJwt(token: string): JwtPayload | null;
+export type ApiConfig = Config;
+export type ApiClient = APIClient;
+export declare function refreshJwtIfNeeded(state: JwtState): Promise<string | null>;
+export declare function createApiClient(config: any): {
+    get: (path: string) => Promise<any>;
+    post: (path: string, body: any) => Promise<any>;
+    handleAuthError: (err: any) => void;
+};
 export declare class APIClient {
     private client;
     private modelRouterClient;
     private selfHostedModelRouterClient;
-    private config;
+    config: Config;
+    token: string | null;
+    expiresAt: number | null;
     private logger;
     private ws;
     private vigFlowTokens;
@@ -226,6 +267,7 @@ export declare class APIClient {
     getMcpBaseUrls(): string[];
     getVigFlowBaseUrls(): string[];
     getTemplateServiceBaseUrls(): string[];
+    private allowLocalServiceFallbacks;
     private isFrontendTask;
     /**
      * Returns true when the prompt describes a read-only / analysis task.
@@ -439,6 +481,24 @@ export declare class APIClient {
      * the fix has fewer closers than the original, appends the missing ones.
      */
     private repairBracketBalance;
+    /**
+     * Build workspace summary re-ordered by semantic relevance to the prompt.
+     * Changed files are listed first, then keyword-matched files, then the rest.
+     * Falls back to plain buildLocalWorkspaceSummary when no prompt is provided.
+     */
+    private buildSemanticWorkspaceSummary;
+    /**
+     * Self-healing cycle: run post-write validators and, if errors are found,
+     * send a targeted correction prompt to the V3 agent (max one healing round).
+     *
+     * This is a best-effort operation — failures never propagate to the user as
+     * hard errors; they are surfaced as a status line in the terminal output.
+     */
+    runSelfHealingCycle(originalPrompt: string, workspacePath: string, context?: Record<string, any>): Promise<{
+        healingAttempted: boolean;
+        passed: boolean;
+        tool: string;
+    }>;
     private resolveModelId;
     private getCoderHealth;
     private getModelsHealth;