vigthoria-cli 1.11.5 → 1.11.7

package/dist/commands/chat.d.ts

@@ -63,6 +63,8 @@ export declare class ChatCommand {
     private getDefaultChatModel;
     private resolveInitialModel;
     private isLegacyAgentFallbackAllowed;
+    private shouldRescueFailedAnalysis;
+    private tryAnalysisLocalRescue;
     private resolveAgentExecutionPolicy;
     private getMessagesForModel;
     private getActivePersonaMode;
@@ -115,6 +117,7 @@ export declare class ChatCommand {
     private consumeV3StreamPayload;
     private writeV3StreamText;
     private sanitizeV3VisibleStreamText;
+    private writeAgentActivityLine;
     private updateV3AgentSpinner;
     private updateOperatorSpinner;
     constructor(config: Config, logger: Logger);

package/dist/commands/chat.js

@@ -13,7 +13,7 @@ import { TaskDisplay } from '../utils/task-display.js';
 import { ProjectMemoryService } from '../utils/project-memory.js';
 import { buildPersonaOverlay, normalizePersonaMode } from '../utils/persona.js';
 import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session-menu.js';
-import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
+import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
@@ -259,6 +259,28 @@ export class ChatCommand {
         // Operators can still opt in during emergency local debugging.
         return process.env.VIGTHORIA_ALLOW_LEGACY_AGENT_FALLBACK === '1';
     }
+    shouldRescueFailedAnalysis() {
+        return process.env.VIGTHORIA_DISABLE_ANALYSIS_RESCUE !== '1';
+    }
+    async tryAnalysisLocalRescue(prompt, workspacePath) {
+        if (!this.shouldRescueFailedAnalysis() || !this.tools) {
+            return false;
+        }
+        const clientToolErrors = this.api.getClientToolErrors();
+        if (clientToolErrors.some((err) => /could not accept the result|client tool bridge failed/i.test(err))) {
+            return false;
+        }
+        console.log('');
+        console.log(chalk.yellow('V3 analysis did not produce a grounded answer — retrying with local workspace tools...'));
+        console.log(chalk.gray(`Workspace: ${workspacePath}`));
+        console.log('');
+        const last = this.messages[this.messages.length - 1];
+        if (last?.role === 'assistant') {
+            this.messages.pop();
+        }
+        await this.runLocalAgentLoop(prompt);
+        return true;
+    }
     resolveAgentExecutionPolicy(prompt) {
         const explicitModel = this.modelExplicitlySelected;
         const heavyTask = this.config.isComplexTask(prompt);
@@ -765,6 +787,11 @@ export class ChatCommand {
             .replace(/\n{3,}/g, '\n\n');
         return output;
     }
+    writeAgentActivityLine(text) {
+        if (this.jsonOutput)
+            return;
+        process.stdout.write(text);
+    }
     updateV3AgentSpinner(spinner, event) {
         if (this.isRawV3StreamPayload(event)) {
             this.consumeV3StreamPayload(spinner, event).catch((error) => {
@@ -785,20 +812,23 @@ export class ChatCommand {
             const toolTarget = event.arguments?.path || event.arguments?.file_path || event.arguments?.pattern || '';
             const sanitizedTarget = this.sanitizeServerPath(String(toolTarget));
             const shortTarget = sanitizedTarget ? ` → ${sanitizedTarget.replace(/\\/g, '/').split('/').slice(-2).join('/')}` : '';
-            const stepLabel = chalk.cyan(`  [${this.v3IterationCount}/${this.v3ToolCallCount}]`) + ` ${toolDesc}${shortTarget}`;
+            const stepLabel = chalk.cyan(`  [${this.v3ToolCallCount}]`) + ` ${toolDesc}${shortTarget}`;
             if (spinner.isSpinning)
                 spinner.stop();
-            process.stderr.write(stepLabel + '\n');
+            this.writeAgentActivityLine(stepLabel + '\n');
             // Show extra detail for key tools
             const args = event.arguments || {};
             const toolName = event.name || event.tool || '';
             if ((toolName === 'write_file' || toolName === 'edit_file') && typeof args.content === 'string') {
                 const len = args.content.length;
-                process.stderr.write(chalk.gray(`      ${len > 1000 ? Math.round(len / 1024) + ' KB' : len + ' bytes'} content\n`));
+                this.writeAgentActivityLine(chalk.gray(`      ${len > 1000 ? Math.round(len / 1024) + ' KB' : len + ' bytes'} content\n`));
             }
             else if (toolName === 'bash' && typeof args.command === 'string') {
                 const command = this.sanitizeServerPath(args.command);
-                process.stderr.write(chalk.gray(`      $ ${command.slice(0, 120)}${command.length > 120 ? '…' : ''}\n`));
+                this.writeAgentActivityLine(chalk.gray(`      $ ${command.slice(0, 120)}${command.length > 120 ? '…' : ''}\n`));
+            }
+            else if (toolName === 'read_file') {
+                this.writeAgentActivityLine(chalk.gray(`      reading ${sanitizedTarget || 'file'}\n`));
             }
             spinner.start();
             spinner.text = `Running ${toolDesc}...`;
@@ -810,18 +840,28 @@ export class ChatCommand {
             const indicator = success ? chalk.green('  ✓') : chalk.red('  ✗');
             if (spinner.isSpinning)
                 spinner.stop();
-            process.stderr.write(`${indicator} ${toolName}\n`);
+            this.writeAgentActivityLine(`${indicator} ${toolName}\n`);
             // Show output for failures, or brief summary for successes — sanitize server paths
             const rawOutput = typeof event.output === 'string' ? event.output.trim() : '';
             const output = this.sanitizeServerPath(rawOutput);
             if (!success && output) {
                 const sanitizedError = this.sanitizeServerPath(typeof event.error === 'string' ? event.error : output);
                 const lines = sanitizedError.split('\n').slice(0, 4);
-                process.stderr.write(chalk.red(`      ${lines.join('\n      ')}\n`));
+                this.writeAgentActivityLine(chalk.red(`      ${lines.join('\n      ')}\n`));
             }
             else if (success && output && output.length > 0) {
-                const brief = output.split('\n')[0].slice(0, 120);
-                process.stderr.write(chalk.gray(`      ${brief}${output.length > 120 ? '…' : ''}\n`));
+                if (toolName === 'read_file' || toolName === 'grep' || toolName === 'search_files' || toolName === 'list_directory') {
+                    const lineCount = output.split('\n').length;
+                    const preview = output.split('\n').slice(0, 3).join('\n');
+                    this.writeAgentActivityLine(chalk.gray(`      ${lineCount} line${lineCount === 1 ? '' : 's'} returned\n`));
+                    if (preview && preview.length > 20 && !/^\(no matches\)$/i.test(preview.trim())) {
+                        this.writeAgentActivityLine(chalk.gray(`${preview.split('\n').map((l) => `      ${l}`).join('\n')}\n`));
+                    }
+                }
+                else {
+                    const brief = output.split('\n')[0].slice(0, 120);
+                    this.writeAgentActivityLine(chalk.gray(`      ${brief}${output.length > 120 ? '…' : ''}\n`));
+                }
             }
             spinner.start();
             spinner.text = 'Next step...';
@@ -836,7 +876,10 @@ export class ChatCommand {
             const iterText = this.sanitizeServerPath(event.content || '');
             if (spinner.isSpinning)
                 spinner.stop();
-            process.stderr.write(chalk.cyan(`\n── ${iterText || `Iteration ${this.v3IterationCount}`} ──\n`));
+            const display = iterText && !/read-only analysis turn|run at least one discovery tool/i.test(iterText)
+                ? iterText
+                : `Step ${this.v3IterationCount}: inspecting workspace…`;
+            this.writeAgentActivityLine(chalk.cyan(`\n── ${display} ──\n`));
             spinner.start();
             spinner.text = 'Analyzing...';
             return;
@@ -2683,39 +2726,6 @@ export class ChatCommand {
             if (!this.jsonOutput && previewGate?.required && previewGate?.passed !== true && workspaceHasOutput) {
                 console.log(chalk.yellow(`Template Service preview gate did not fully validate this output, but generated workspace files were preserved${previewGate?.error ? `: ${previewGate.error}` : '.'}`));
             }
-            if (this.v3StreamingStarted) {
-                // Content was already streamed to stdout in real-time; skip duplicate print.
-                if (!this.jsonOutput) {
-                    console.log(chalk.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'}`));
-                }
-            }
-            else if (answerContent) {
-                if (!this.directPromptMode) {
-                    console.log(chalk.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'}`));
-                }
-                console.log('');
-                console.log(chalk.bold('Answer:'));
-                console.log(answerContent);
-            }
-            else if (response.content) {
-                if (!this.directPromptMode) {
-                    console.log(chalk.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'}`));
-                }
-                console.log(response.content);
-            }
-            else if (!requiresWorkspaceChanges) {
-                if (!this.directPromptMode) {
-                    console.log(chalk.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'}`));
-                }
-                console.log(chalk.yellow('The agent finished without producing an answer to your question.'));
-                console.log(chalk.gray('Try /retry or ask again with more detail (e.g. file name or feature).'));
-            }
-            else {
-                if (!this.directPromptMode) {
-                    console.log(chalk.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'}`));
-                }
-                console.log('V3 agent workflow completed.');
-            }
             if (!this.jsonOutput && previewGate?.required) {
                 if (previewGate.passed) {
                     console.log(chalk.gray(`Template Service preview gate: passed via ${previewGate.backendUrl || 'unknown backend'}`));
@@ -2743,8 +2753,43 @@ export class ChatCommand {
             // executor errors and the spinner needs to clearly say "failed", not "✓".
             let selfHealStatus = null;
             let selfHealTool = null;
+            if (isToolEvidenceStubAnswer(answerContent)) {
+                liveOutcome.answerContent = '';
+            }
             const runEvaluation = evaluateExecutorSuccess(liveOutcome);
-            const executorSucceeded = runEvaluation.executorSucceeded;
+            let executorSucceeded = runEvaluation.executorSucceeded;
+            let finalAnswer = answerContent;
+            const needsAnalysisRescue = !requiresWorkspaceChanges && !this.jsonOutput
+                && (!executorSucceeded || !isSubstantiveAgentAnswer(finalAnswer));
+            if (needsAnalysisRescue) {
+                const rescued = await this.tryAnalysisLocalRescue(prompt, workspacePath);
+                if (rescued) {
+                    watcher?.stop();
+                    return true;
+                }
+                executorSucceeded = false;
+            }
+            if (!this.jsonOutput && !this.directPromptMode) {
+                if (this.v3StreamingStarted && isSubstantiveAgentAnswer(this.v3StreamedAnswerBuffer)) {
+                    console.log('');
+                    console.log(chalk.bold('Answer:'));
+                    console.log(this.v3StreamedAnswerBuffer.trim());
+                }
+                else if (isSubstantiveAgentAnswer(finalAnswer)) {
+                    console.log('');
+                    console.log(chalk.bold('Answer:'));
+                    console.log(finalAnswer);
+                }
+                else if (!requiresWorkspaceChanges) {
+                    console.log('');
+                    console.log(chalk.yellow('No written analysis was produced for your question.'));
+                    console.log(chalk.gray('The agent inspected files but did not synthesize findings. Try /retry or rephrase (e.g. "Summarize architecture of index.html and game.js").'));
+                }
+                else if (finalAnswer) {
+                    console.log('');
+                    console.log(finalAnswer);
+                }
+            }
             if (!executorSucceeded && requiresWorkspaceChanges && changedFileCount === 0 && !liveOutcome.executorError) {
                 const clientToolErrors = this.api.getClientToolErrors();
                 const transportErrors = this.api.getLastChatTransportErrors();
@@ -2839,7 +2884,7 @@ export class ChatCommand {
                 clientToolErrors: this.api.getClientToolErrors(),
                 transportErrors: this.api.getLastChatTransportErrors(),
                 workspacePath: workspacePath || null,
-                workspaceSyncIssue: (!executorSucceeded && workspaceHasOutput && changedFileCount === 0)
+                workspaceSyncIssue: (!executorSucceeded && requiresWorkspaceChanges && workspaceHasOutput && changedFileCount === 0)
                     ? 'Local workspace has files but the agent did not confirm tracked changes.'
                     : null,
                 finishedAt: Date.now(),
@@ -3352,7 +3397,7 @@ export class ChatCommand {
                 : `${outcome.tasksSucceeded} task update${outcome.tasksSucceeded === 1 ? '' : 's'} reported`;
             console.log('  ' + chalk.white(taskLine + '.'));
         }
-        else if (outcome.answerContent) {
+        else if (outcome.answerContent && isSubstantiveAgentAnswer(outcome.answerContent)) {
             const preview = outcome.answerContent.length > 160
                 ? `${outcome.answerContent.slice(0, 160)}…`
                 : outcome.answerContent;

package/dist/utils/agentRunOutcome.d.ts

@@ -31,6 +31,8 @@ export interface RunEvaluation {
     uiTheme: 'success' | 'warning' | 'error';
 }
 export declare function createLiveOutcome(): LiveOutcome;
+/** Tool-trace stubs like `[read_file] "index.html"` — not a user-facing answer. */
+export declare function isToolEvidenceStubAnswer(text: string): boolean;
 /** True when text looks like a real answer, not an executor/system placeholder. */
 export declare function isSubstantiveAgentAnswer(text: string): boolean;
 /** Pick the first substantive answer from response body and/or streamed text. */

package/dist/utils/agentRunOutcome.js

@@ -27,15 +27,37 @@ const LIST_ONLY_DISCOVERY_TOOLS = new Set([
     'glob',
     'dir',
 ]);
+const GENERIC_SUMMARY_RE = /^(completed the requested analysis|reviewed the workspace without writing changes|task completed|done|finished|analysis completed)([.\s]|$)/i;
+/** Tool-trace stubs like `[read_file] "index.html"` — not a user-facing answer. */
+export function isToolEvidenceStubAnswer(text) {
+    const trimmed = String(text || '').trim();
+    if (!trimmed)
+        return true;
+    if (GENERIC_SUMMARY_RE.test(trimmed.replace(/\.\s*\d+\s+tool steps.*$/i, '').trim()))
+        return true;
+    const lines = trimmed.split('\n').map((line) => line.trim()).filter(Boolean);
+    if (lines.length === 0)
+        return true;
+    const stubLine = /^\[(?:read_file|grep|list_directory|search_files|glob|tool_call)\]/i;
+    const filesOnly = /^Files inspected:/i;
+    const stubLines = lines.filter((line) => stubLine.test(line) || filesOnly.test(line)).length;
+    if (stubLines === lines.length)
+        return true;
+    if (stubLines > 0 && stubLines / lines.length >= 0.6 && trimmed.length < 400)
+        return true;
+    return false;
+}
 /** True when text looks like a real answer, not an executor/system placeholder. */
 export function isSubstantiveAgentAnswer(text) {
     const trimmed = String(text || '').trim();
-    if (trimmed.length < 30)
+    if (trimmed.length < 80)
         return false;
     if (EXECUTOR_PLACEHOLDER_RE.test(trimmed))
         return false;
     if (/^v3 agent workflow completed\.?$/i.test(trimmed))
         return false;
+    if (isToolEvidenceStubAnswer(trimmed))
+        return false;
     return true;
 }
 /** Pick the first substantive answer from response body and/or streamed text. */

package/dist/utils/api.js

@@ -11,7 +11,7 @@ import path from 'path';
 import WebSocket from 'ws';
 import { buildSemanticContext } from './context-ranker.js';
 import { getChangedFiles } from './workspace-cache.js';
-import { isSubstantiveAgentAnswer } from './agentRunOutcome.js';
+import { isSubstantiveAgentAnswer, isToolEvidenceStubAnswer } from './agentRunOutcome.js';
 export const VIGTHORIA_HUB_CREDITS_URL = 'https://hub.vigthoria.io/credits';
 export const VIGTHORIA_SERVER_TEMPORARILY_UNAVAILABLE_MESSAGE = 'Vigthoria Server is temporarily not available. Please try again later. If the issue persists, please contact support.';
 export class CLIError extends Error {
@@ -2745,9 +2745,10 @@ menu {
                     .map((entry) => `${entry.isDirectory() ? '[DIR] ' : ''}${entry.name}`);
                 return { success: true, output: entries.join('\n') || '(empty)' };
             }
-            if (name === 'glob' || name === 'search_files') {
+            if (name === 'glob' || name === 'search_files' || name === 'grep') {
                 const pattern = String(args.pattern || args.query || '').toLowerCase();
                 const files = [];
+                const matches = [];
                 const walk = (dir) => {
                     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
                         if (['node_modules', '.git'].includes(entry.name))
@@ -2758,18 +2759,30 @@ menu {
                             continue;
                         }
                         const relative = path.relative(rootPath, absolute).replace(/\\/g, '/');
-                        if (!pattern || relative.toLowerCase().includes(pattern.replace(/\*/g, ''))) {
-                            files.push(relative);
-                        }
-                        else if (name === 'search_files') {
-                            const content = fs.readFileSync(absolute, 'utf8');
-                            if (content.toLowerCase().includes(pattern))
+                        if (name === 'glob' && pattern) {
+                            if (!pattern || relative.toLowerCase().includes(pattern.replace(/\*/g, ''))) {
                                 files.push(relative);
+                            }
+                        }
+                        else if (pattern) {
+                            try {
+                                const content = fs.readFileSync(absolute, 'utf8');
+                                if (relative.toLowerCase().includes(pattern.replace(/\*/g, '')) || content.toLowerCase().includes(pattern)) {
+                                    matches.push(`${relative}: ${content.split('\n').find((line) => line.toLowerCase().includes(pattern))?.trim() || '(match)'}`);
+                                }
+                            }
+                            catch {
+                                // skip unreadable/binary files
+                            }
                         }
                     }
                 };
-                walk(fs.statSync(target.absolutePath).isDirectory() ? target.absolutePath : rootPath);
-                return { success: true, output: files.slice(0, 200).join('\n') || '(no matches)' };
+                const searchRoot = fs.statSync(target.absolutePath).isDirectory() ? target.absolutePath : rootPath;
+                walk(searchRoot);
+                if (name === 'glob') {
+                    return { success: true, output: files.slice(0, 200).join('\n') || '(no matches)' };
+                }
+                return { success: true, output: matches.slice(0, 100).join('\n') || '(no matches)' };
             }
             if (name === 'syntax_check') {
                 const content = fs.readFileSync(target.absolutePath, 'utf8');
@@ -2805,8 +2818,27 @@ menu {
         if (!contextId || !callId)
             return;
         const backendUrl = responseUrl ? new URL(responseUrl).origin : (context.mcpContextBackendUrl || null);
+        const emitStream = (streamEvent) => {
+            if (typeof context.onStreamEvent === 'function') {
+                try {
+                    context.onStreamEvent(streamEvent);
+                }
+                catch {
+                    // UI callbacks must never break the client tool bridge.
+                }
+            }
+        };
+        emitStream({ type: 'tool_call', name: toolName, tool: toolName, arguments: event.arguments || {} });
         try {
             const result = await this.executeV3ClientToolRequest(event, context);
+            emitStream({
+                type: 'tool_result',
+                name: toolName,
+                tool: toolName,
+                success: result.success,
+                output: result.output,
+                error: result.error || '',
+            });
             try {
                 await this.submitClientToolResult(contextId, callId, result, backendUrl);
             }
@@ -3370,22 +3402,45 @@ document.addEventListener('DOMContentLoaded', () => {
     synthesizeAnswerFromV3Events(events) {
         const toolResults = [];
         const filesRead = [];
+        const readExcerpts = [];
         const filesWritten = [];
         const assistantFragments = [];
+        const pendingReadPaths = new Map();
+        let readIndex = 0;
         for (const event of events) {
             if (!event)
                 continue;
+            if (event.type === 'tool_call') {
+                const name = String(event.name || event.tool || '').trim();
+                if (name === 'read_file') {
+                    const target = event.arguments?.path || event.arguments?.file_path || event.target;
+                    if (target)
+                        pendingReadPaths.set(readIndex++, String(target));
+                }
+            }
             if (event.type === 'tool_result' && event.success && typeof event.output === 'string') {
-                const name = event.name || 'unknown_tool';
-                if (name === 'read_file' && typeof event.target === 'string') {
-                    filesRead.push(sanitizeUserFacingPathText(event.target));
+                const name = String(event.name || event.tool || 'unknown_tool').trim();
+                const output = event.output.trim();
+                if (name === 'read_file') {
+                    const target = typeof event.target === 'string'
+                        ? event.target
+                        : (event.arguments?.path || event.arguments?.file_path || filesRead[filesRead.length] || 'file');
+                    if (target)
+                        filesRead.push(sanitizeUserFacingPathText(String(target)));
+                    if (output.length > 120 && !/^"[^"]+"$/.test(output)) {
+                        const header = sanitizeUserFacingPathText(String(target || 'file'));
+                        const body = sanitizeUserFacingPathText(output.slice(0, 2500));
+                        readExcerpts.push(`${header}\n${body}${output.length > 2500 ? '\n…' : ''}`);
+                    }
+                    else if (output.length > 0) {
+                        toolResults.push(`[${name}] ${sanitizeUserFacingPathText(output.slice(0, 300))}`);
+                    }
                 }
                 else if ((name === 'write_file' || name === 'create_file') && typeof event.target === 'string') {
                     filesWritten.push(sanitizeUserFacingPathText(event.target));
                 }
                 else {
-                    // Keep last ~300 chars of output for context
-                    const excerpt = event.output.length > 300 ? event.output.slice(-300) : event.output;
+                    const excerpt = output.length > 300 ? output.slice(-300) : output;
                     toolResults.push(`[${name}] ${sanitizeUserFacingPathText(excerpt)}`);
                 }
             }
@@ -3410,10 +3465,13 @@ document.addEventListener('DOMContentLoaded', () => {
         // Concatenate ALL assistant text fragments in order — keeps full
         // multi-turn reasoning instead of only the last fragment.
         const fullAssistantText = assistantFragments.join('\n\n').trim();
-        if (fullAssistantText.length > 20) {
+        if (isSubstantiveAgentAnswer(fullAssistantText)) {
             return fullAssistantText;
         }
-        // Otherwise build a summary from tool evidence
+        if (readExcerpts.length > 0) {
+            return '';
+        }
+        // Otherwise build a summary from tool evidence — but never treat stubs as answers.
         const sections = [];
         if (filesRead.length > 0) {
             sections.push(`Files inspected: ${filesRead.join(', ')}`);
@@ -3424,9 +3482,8 @@ document.addEventListener('DOMContentLoaded', () => {
         if (toolResults.length > 0) {
             sections.push(toolResults.slice(-5).join('\n'));
         }
-        return sections.length > 0
-            ? sections.join('\n\n')
-            : '';
+        const synthesized = sections.join('\n\n');
+        return isToolEvidenceStubAnswer(synthesized) ? '' : synthesized;
     }
     sanitizeV3AgentEventForUser(event) {
         const sanitizeValue = (value) => {
@@ -3646,6 +3703,7 @@ document.addEventListener('DOMContentLoaded', () => {
                     // Exit stream early on complete — agent is done; server-side teardown
                     // can hold the connection open for many seconds otherwise.
                     if (event.type === 'complete') {
+                        await Promise.allSettled([...this.pendingV3ClientToolTasks]);
                         reader.cancel().catch(() => { });
                         return {
                             task_id: events.find((entry) => entry && entry.task_id)?.task_id || null,

package/package.json

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