vigthoria-cli 1.11.7 → 1.11.9

package/dist/commands/agent-session-menu.js

@@ -6,6 +6,15 @@ import inquirer from 'inquirer';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+function terminalColumns() {
+    const raw = Number(process.stdout.columns || 80);
+    return Number.isFinite(raw) && raw > 0 ? raw : 80;
+}
+function fitLine(text, reserve = 0) {
+    const width = Math.max(24, terminalColumns() - reserve);
+    const clean = String(text || '').replace(/\s+/g, ' ').trim();
+    return clean.length > width ? `${clean.slice(0, Math.max(1, width - 1))}…` : clean;
+}
 function validateExistingDirectory(input) {
     const trimmed = String(input || '').trim().replace(/^['"]|['"]$/g, '');
     if (!trimmed) {
@@ -84,8 +93,8 @@ export async function runAgentSessionMenu(defaults = {}) {
     };
     console.log();
     console.log(chalk.cyan('═══ Agent Session Setup ═══'));
-    console.log(chalk.gray(`Workspace: ${session.workspacePath}`));
-    console.log(chalk.gray(`Debug: ${session.debugMode ? 'on' : 'off'} | Auto-approve: ${session.autoApprove ? 'on' : 'off'} | Auto-save: ${session.autoSave ? 'on' : 'off'}`));
+    console.log(chalk.gray(fitLine(`Workspace: ${session.workspacePath}`)));
+    console.log(chalk.gray(fitLine(`Debug: ${session.debugMode ? 'on' : 'off'} | Auto-approve: ${session.autoApprove ? 'on' : 'off'} | Auto-save: ${session.autoSave ? 'on' : 'off'}`)));
     console.log();
     const { action } = await inquirer.prompt([
         {
@@ -153,8 +162,8 @@ export async function runAgentSessionMenu(defaults = {}) {
     }
     console.log();
     console.log(chalk.cyan('── Session ready ──'));
-    console.log(chalk.gray(`Workspace: ${session.workspacePath}`));
-    console.log(chalk.gray(`Debug: ${session.debugMode ? 'on' : 'off'} | Auto-approve: ${session.autoApprove ? 'on' : 'off'} | Auto-save: ${session.autoSave ? 'on' : 'off'}`));
+    console.log(chalk.gray(fitLine(`Workspace: ${session.workspacePath}`)));
+    console.log(chalk.gray(fitLine(`Debug: ${session.debugMode ? 'on' : 'off'} | Auto-approve: ${session.autoApprove ? 'on' : 'off'} | Auto-save: ${session.autoSave ? 'on' : 'off'}`)));
     console.log();
     return session;
 }

package/dist/commands/chat.d.ts

@@ -48,6 +48,8 @@ export declare class ChatCommand {
     private retryPromptStreak;
     private v3SuppressThinkingStream;
     private v3StreamedAnswerBuffer;
+    private v3SeenToolCalls;
+    private v3SeenToolResults;
     private lastAgentRunOutcome;
     private isJwtExpirationError;
     private isNetworkError;
@@ -64,6 +66,7 @@ export declare class ChatCommand {
     private resolveInitialModel;
     private isLegacyAgentFallbackAllowed;
     private shouldRescueFailedAnalysis;
+    private isDeepAnalysisPrompt;
     private tryAnalysisLocalRescue;
     private resolveAgentExecutionPolicy;
     private getMessagesForModel;
@@ -113,6 +116,10 @@ export declare class ChatCommand {
     private sanitizeServerPath;
     private stripHiddenThoughtBlocks;
     private describeV3AgentTool;
+    private terminalColumns;
+    private fitTerminalText;
+    private normalizeToolOutputForDisplay;
+    private toolEventKey;
     private isRawV3StreamPayload;
     private consumeV3StreamPayload;
     private writeV3StreamText;

package/dist/commands/chat.js

@@ -67,6 +67,8 @@ export class ChatCommand {
     retryPromptStreak = 0;
     v3SuppressThinkingStream = false;
     v3StreamedAnswerBuffer = '';
+    v3SeenToolCalls = new Set();
+    v3SeenToolResults = new Set();
     // Last completed Agent run — used by /retry, /continue, and the final summary block.
     lastAgentRunOutcome = null;
     isJwtExpirationError(error) {
@@ -262,6 +264,10 @@ export class ChatCommand {
     shouldRescueFailedAnalysis() {
         return process.env.VIGTHORIA_DISABLE_ANALYSIS_RESCUE !== '1';
     }
+    isDeepAnalysisPrompt(prompt) {
+        return /\b(deep|deeper|full|complete|thorough|systematic|architecture|architectural)\s+(analyse|analyze|analysis|review|dive|scan)\b/i.test(prompt)
+            || /\b(analyse|analyze|analysis|review)\b[\s\S]{0,40}\b(deep|deeper|full|complete|thorough|systematic|architecture|architectural)\b/i.test(prompt);
+    }
     async tryAnalysisLocalRescue(prompt, workspacePath) {
         if (!this.shouldRescueFailedAnalysis() || !this.tools) {
             return false;
@@ -702,6 +708,33 @@ export class ChatCommand {
         }
         return 'Working';
     }
+    terminalColumns() {
+        const raw = Number(process.stdout.columns || process.stderr.columns || 80);
+        return Number.isFinite(raw) && raw > 0 ? raw : 80;
+    }
+    fitTerminalText(text, reserve = 0) {
+        const width = Math.max(24, this.terminalColumns() - reserve);
+        const clean = String(text || '').replace(/\s+/g, ' ').trim();
+        const visible = clean.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+        if (visible.length <= width)
+            return clean;
+        return `${visible.slice(0, Math.max(1, width - 1))}…`;
+    }
+    normalizeToolOutputForDisplay(output) {
+        return String(output || '')
+            .replace(/\/r\/n|\/n|\\n/g, '\n')
+            .replace(/\/r|\\r/g, '')
+            .replace(/\t/g, '  ');
+    }
+    toolEventKey(event) {
+        const name = String(event?.name || event?.tool || event?.tool_name || '').trim();
+        const args = event?.arguments && typeof event.arguments === 'object' ? event.arguments : {};
+        const target = String(args.path || args.file_path || args.pattern || args.command || event?.target || '').trim();
+        if (target)
+            return `${name}:${target}`;
+        const output = typeof event?.output === 'string' ? event.output.replace(/\s+/g, ' ').slice(0, 160) : '';
+        return `${name}:${output}`;
+    }
     isRawV3StreamPayload(event) {
         if (!event) {
             return false;
@@ -784,6 +817,9 @@ export class ChatCommand {
             .replace(/^\s*(?:list_dir|read_file|write_file|edit_file|glob|grep|bash)\s*$/gim, '')
             .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
             .replace(/<tool_code>[\s\S]*?<\/tool_code>/gi, '')
+            .replace(/<read_file>\s*<path>[\s\S]*?<\/path>\s*<\/read_file>/gi, '')
+            .replace(/<(?:grep|list_directory|search_files|glob|tool_result)\b[\s\S]*?<\/(?:grep|list_directory|search_files|glob|tool_result)>/gi, '')
+            .replace(/bootstrap discovery completed\s*[—-]\s*inspect the most relevant files next\.?/gi, '')
             .replace(/\n{3,}/g, '\n\n');
         return output;
     }
@@ -807,15 +843,20 @@ export class ChatCommand {
         }
         this.v3LastActivity = Date.now();
         if (event.type === 'tool_call') {
+            const eventKey = this.toolEventKey(event);
+            if (this.v3SeenToolCalls.has(eventKey)) {
+                return;
+            }
+            this.v3SeenToolCalls.add(eventKey);
             this.v3ToolCallCount += 1;
             const toolDesc = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
             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 shortTarget = sanitizedTarget ? ` -> ${sanitizedTarget.replace(/\\/g, '/').split('/').slice(-2).join('/')}` : '';
             const stepLabel = chalk.cyan(`  [${this.v3ToolCallCount}]`) + ` ${toolDesc}${shortTarget}`;
             if (spinner.isSpinning)
                 spinner.stop();
-            this.writeAgentActivityLine(stepLabel + '\n');
+            this.writeAgentActivityLine(this.fitTerminalText(stepLabel) + '\n');
             // Show extra detail for key tools
             const args = event.arguments || {};
             const toolName = event.name || event.tool || '';
@@ -825,16 +866,21 @@ export class ChatCommand {
             }
             else if (toolName === 'bash' && typeof args.command === 'string') {
                 const command = this.sanitizeServerPath(args.command);
-                this.writeAgentActivityLine(chalk.gray(`      $ ${command.slice(0, 120)}${command.length > 120 ? '…' : ''}\n`));
+                this.writeAgentActivityLine(chalk.gray(`      ${this.fitTerminalText(`$ ${command}`, 6)}\n`));
             }
             else if (toolName === 'read_file') {
-                this.writeAgentActivityLine(chalk.gray(`      reading ${sanitizedTarget || 'file'}\n`));
+                this.writeAgentActivityLine(chalk.gray(`      ${this.fitTerminalText(`reading ${sanitizedTarget || 'file'}`, 6)}\n`));
             }
-            spinner.start();
             spinner.text = `Running ${toolDesc}...`;
             return;
         }
         if (event.type === 'tool_result') {
+            const eventKey = this.toolEventKey(event);
+            if (eventKey && this.v3SeenToolResults.has(eventKey)) {
+                return;
+            }
+            if (eventKey)
+                this.v3SeenToolResults.add(eventKey);
             const success = event.success !== false;
             const toolName = event.name || event.tool || '';
             const indicator = success ? chalk.green('  ✓') : chalk.red('  ✗');
@@ -843,27 +889,30 @@ export class ChatCommand {
             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);
+            const output = this.normalizeToolOutputForDisplay(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);
-                this.writeAgentActivityLine(chalk.red(`      ${lines.join('\n      ')}\n`));
+                this.writeAgentActivityLine(chalk.red(`${lines.map((line) => `      ${this.fitTerminalText(line, 6)}`).join('\n')}\n`));
             }
             else if (success && output && output.length > 0) {
                 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');
+                    const preview = output.split('\n')
+                        .map((line) => line.trim())
+                        .filter((line) => line && !line.startsWith('.vigthoria/memory/brain.json:'))
+                        .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`));
+                        this.writeAgentActivityLine(chalk.gray(`${preview.split('\n').map((line) => `      ${this.fitTerminalText(line, 6)}`).join('\n')}\n`));
                     }
                 }
                 else {
-                    const brief = output.split('\n')[0].slice(0, 120);
-                    this.writeAgentActivityLine(chalk.gray(`      ${brief}${output.length > 120 ? '…' : ''}\n`));
+                    const brief = output.split('\n')[0];
+                    this.writeAgentActivityLine(chalk.gray(`      ${this.fitTerminalText(brief, 6)}\n`));
                 }
             }
-            spinner.start();
             spinner.text = 'Next step...';
             return;
         }
@@ -879,8 +928,7 @@ export class ChatCommand {
             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();
+            this.writeAgentActivityLine(chalk.cyan(`\n── ${this.fitTerminalText(display, 6)} ──\n`));
             spinner.text = 'Analyzing...';
             return;
         }
@@ -913,13 +961,13 @@ export class ChatCommand {
                 if (fail > 0)
                     statLine += chalk.yellow(`, ${fail} failed`);
             }
-            process.stderr.write(chalk.green(`\n✓ Complete`) + ` — ${statLine}\n`);
+            process.stdout.write(chalk.green(`\n✓ Complete`) + ` - ${this.fitTerminalText(statLine, 14)}\n`);
             // Show seal quality score if available
             if (event.seal_score && typeof event.seal_score.overall === 'number') {
                 const score = event.seal_score.overall;
                 const tier = event.seal_score.tier || '';
                 const scoreColor = score >= 7 ? chalk.green : score >= 5 ? chalk.yellow : chalk.red;
-                process.stderr.write(chalk.cyan('  [Quality] ') + scoreColor(`${score}/10`) + (tier ? chalk.gray(` (${tier})`) : '') + '\n');
+                process.stdout.write(chalk.cyan('  [Quality] ') + scoreColor(`${score}/10`) + (tier ? chalk.gray(` (${tier})`) : '') + '\n');
             }
             return;
         }
@@ -936,35 +984,31 @@ export class ChatCommand {
             }
             if (spinner.isSpinning)
                 spinner.stop();
-            process.stderr.write(chalk.cyan(`  [Plan] `) + `Task: ${planKind || 'analyzing'}`);
-            if (quality)
-                process.stderr.write(chalk.gray(` (${quality})`));
-            process.stderr.write('\n');
+            process.stdout.write(chalk.cyan(`  [Plan] `) + this.fitTerminalText(`Task: ${planKind || 'analyzing'}${quality ? ` (${quality})` : ''}`, 9) + '\n');
             if (summary) {
-                process.stderr.write(chalk.gray(`      ${summary}\n`));
+                process.stdout.write(chalk.gray(`      ${this.fitTerminalText(summary, 6)}\n`));
             }
             if (status === 'planning' && Number.isFinite(Number(plan.elapsed_seconds))) {
-                process.stderr.write(chalk.gray(`      elapsed: ${plan.elapsed_seconds}s\n`));
+                process.stdout.write(chalk.gray(`      elapsed: ${plan.elapsed_seconds}s\n`));
             }
             if (Array.isArray(plan.tasks) && plan.tasks.length > 0) {
-                process.stderr.write(chalk.gray(`      ${plan.total_tasks || plan.tasks.length} tasks:\n`));
+                process.stdout.write(chalk.gray(`      ${plan.total_tasks || plan.tasks.length} tasks:\n`));
                 for (const t of plan.tasks.slice(0, 10)) {
                     const targets = Array.isArray(t.targets) && t.targets.length ? ` → ${t.targets.map((target) => this.sanitizeServerPath(String(target))).join(', ')}` : '';
-                    process.stderr.write(chalk.gray(`        • ${this.sanitizeServerPath(String(t.title || t.id))}${targets}\n`));
+                    process.stdout.write(chalk.gray(`        - ${this.fitTerminalText(`${this.sanitizeServerPath(String(t.title || t.id))}${targets}`, 10)}\n`));
                 }
                 if (plan.tasks.length > 10) {
-                    process.stderr.write(chalk.gray(`        ... and ${plan.tasks.length - 10} more\n`));
+                    process.stdout.write(chalk.gray(`        ... and ${plan.tasks.length - 10} more\n`));
                 }
             }
             if (Array.isArray(plan.notes) && plan.notes.length > 0) {
                 for (const note of plan.notes.slice(0, 3)) {
-                    process.stderr.write(chalk.gray(`      note: ${this.sanitizeServerPath(String(note))}\n`));
+                    process.stdout.write(chalk.gray(`      note: ${this.fitTerminalText(this.sanitizeServerPath(String(note)), 12)}\n`));
                 }
             }
             if (Array.isArray(plan.target_files) && plan.target_files.length > 0) {
-                process.stderr.write(chalk.gray(`      Files: ${plan.target_files.map((filePath) => this.sanitizeServerPath(String(filePath))).join(', ')}\n`));
+                process.stdout.write(chalk.gray(`      ${this.fitTerminalText(`Files: ${plan.target_files.map((filePath) => this.sanitizeServerPath(String(filePath))).join(', ')}`, 6)}\n`));
             }
-            spinner.start();
             spinner.text = status === 'planning' ? 'Planning...' : 'Executing plan...';
             return;
         }
@@ -1187,7 +1231,7 @@ export class ChatCommand {
             if (sessionConfig.debugMode) {
                 process.env.DEBUG = process.env.DEBUG || 'vigthoria:*';
             }
-            console.log(chalk.green(`Using workspace: ${this.currentProjectPath}`));
+            console.log(chalk.green(this.fitTerminalText(`Using workspace: ${this.currentProjectPath}`)));
         }
         if (this.jsonOutput && !options.prompt && !options.retry && !options.continue) {
             throw new Error('--json is only supported together with --prompt, --retry, or --continue.');
@@ -1988,6 +2032,7 @@ export class ChatCommand {
     buildLocalLoopLiveOutcome(prompt) {
         const liveOutcome = createLiveOutcome();
         liveOutcome.requiresWorkspaceChanges = this.taskRequiresWorkspaceChanges(prompt);
+        liveOutcome.deepAnalysisRequired = this.isDeepAnalysisPrompt(prompt);
         liveOutcome.analysisToolsUsed = this.agentToolEvidence.discovery;
         liveOutcome.changedFileCount = this.agentToolEvidence.mutation;
         liveOutcome.workspaceHasOutput = this.agentToolEvidence.mutation > 0;
@@ -2500,11 +2545,14 @@ export class ChatCommand {
         this.v3LastActivity = Date.now();
         this.v3StreamingStarted = false;
         this.v3StreamedAnswerBuffer = '';
-        const taskDisplay = new TaskDisplay(['Analyse workspace', 'Execute tasks', 'Validate output', 'Self-heal'], !this.jsonOutput);
+        this.v3SeenToolCalls.clear();
+        this.v3SeenToolResults.clear();
+        const taskDisplay = new TaskDisplay(['Analyse workspace', 'Execute tasks', 'Validate output', 'Self-heal'], false);
         taskDisplay.start(0);
         const spinner = this.jsonOutput ? null : createSpinner({
             text: routingPolicy.cloudSelected ? 'Routing heavy task to Vigthoria Cloud...' : 'Routing to V3 Agent...',
             spinner: 'clock',
+            isSilent: true,
         }).start();
         // Live run telemetry, used both for the final summary block and for /retry, /continue.
         const liveOutcome = {
@@ -2514,6 +2562,7 @@ export class ChatCommand {
             qualityMissing: [],
             qualityBlockers: [],
         };
+        liveOutcome.deepAnalysisRequired = this.isDeepAnalysisPrompt(prompt);
         const parsePlannerSummary = (raw) => {
             if (!raw || typeof raw !== 'string')
                 return;
@@ -2648,6 +2697,12 @@ export class ChatCommand {
                         if (Number(event.discovery_tools_used) > 0) {
                             liveOutcome.analysisToolsUsed = Math.max(liveOutcome.analysisToolsUsed, Number(event.discovery_tools_used));
                         }
+                        if (Number(event.discovery_read_files) > 0) {
+                            liveOutcome.analysisReadToolsUsed = Math.max(liveOutcome.analysisReadToolsUsed, Number(event.discovery_read_files));
+                        }
+                        if (event.analysis_deep_required === true) {
+                            liveOutcome.deepAnalysisRequired = true;
+                        }
                         taskDisplay.complete(1);
                     }
                     else if (event.type === 'executor_error') {
@@ -2759,6 +2814,9 @@ export class ChatCommand {
             const runEvaluation = evaluateExecutorSuccess(liveOutcome);
             let executorSucceeded = runEvaluation.executorSucceeded;
             let finalAnswer = answerContent;
+            if (isToolEvidenceStubAnswer(finalAnswer)) {
+                finalAnswer = '';
+            }
             const needsAnalysisRescue = !requiresWorkspaceChanges && !this.jsonOutput
                 && (!executorSucceeded || !isSubstantiveAgentAnswer(finalAnswer));
             if (needsAnalysisRescue) {
@@ -2876,7 +2934,7 @@ export class ChatCommand {
                 qualityMissing: liveOutcome.qualityMissing,
                 qualityBlockers: liveOutcome.qualityBlockers,
                 hasOutput: workspaceHasOutput,
-                answerContent: answerContent || null,
+                answerContent: finalAnswer || null,
                 selfHealStatus,
                 selfHealTool,
                 plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
@@ -2904,7 +2962,7 @@ export class ChatCommand {
                     taskId: response.taskId || null,
                     contextId: response.contextId || null,
                     partial: response.partial === true || (!executorSucceeded && liveOutcome.tasksSucceeded > 0),
-                    content: answerContent || response.content || runEvaluation.statusHeadline,
+                    content: finalAnswer || runEvaluation.statusHeadline,
                     statusHeadline: runEvaluation.statusHeadline,
                     tasksSucceeded: liveOutcome.tasksSucceeded,
                     tasksTotal: liveOutcome.tasksTotal,
@@ -2920,7 +2978,7 @@ export class ChatCommand {
                     },
                 }, null, 2));
             }
-            this.messages.push({ role: 'assistant', content: answerContent || response.content || runEvaluation.statusHeadline });
+            this.messages.push({ role: 'assistant', content: finalAnswer || runEvaluation.statusHeadline });
             watcher?.stop();
             return true;
         }
@@ -3087,10 +3145,10 @@ export class ChatCommand {
                 ? 'Interactive Agent Chat'
                 : 'Interactive Chat';
         this.logger.section(this.workflowTarget ? `${chatTitle} Via Workflow Target` : chatTitle);
-        console.log(chalk.gray('Type /help for commands. Type /exit to quit.'));
-        console.log(chalk.gray('Multi-line: end a line with \\ or start a block with {{{ and end with }}}'));
+        console.log(chalk.gray(this.fitTerminalText('Type /help for commands. Type /exit to quit.')));
+        console.log(chalk.gray(this.fitTerminalText('Multi-line: end a line with \\ or start a block with {{{ and end with }}}')));
         if (this.workflowTarget) {
-            console.log(chalk.gray(`Workflow target: ${this.workflowTarget}`));
+            console.log(chalk.gray(this.fitTerminalText(`Workflow target: ${this.workflowTarget}`)));
         }
         const rl = readline.createInterface({
             input: process.stdin,

package/dist/index.js

@@ -567,22 +567,34 @@ export async function main(args) {
             return;
         }
     }
-    // Banner - Fixed alignment with proper padding
-    const boxWidth = 61; // Inner content width
-    const titleText = 'VIGTHORIA CLI - AI-Powered Coding Assistant';
-    const versionText = `Version ${VERSION}`;
-    // Calculate padding for centering
-    const titlePad = Math.floor((boxWidth - 4 - titleText.length) / 2);
-    const versionPad = Math.floor((boxWidth - 4 - versionText.length) / 2);
     if (process.env.VIGTHORIA_NO_BANNER !== '1' &&
         !jsonOutputRequested &&
         !directPromptRequested &&
         !helpOrVersionRequested) {
+        const terminalWidth = Math.max(36, Number(process.stdout.columns || 80));
+        const boxWidth = Math.max(34, Math.min(61, terminalWidth - 2));
+        const innerWidth = boxWidth;
+        const fit = (text) => {
+            const clean = String(text || '').replace(/\s+/g, ' ').trim();
+            return clean.length > innerWidth ? `${clean.slice(0, Math.max(1, innerWidth - 1))}…` : clean;
+        };
+        const center = (text, colour = (value) => value) => {
+            const fitted = fit(text);
+            const left = Math.max(0, Math.floor((innerWidth - fitted.length) / 2));
+            const right = Math.max(0, innerWidth - fitted.length - left);
+            return chalk.cyan(CH.dV) + ' '.repeat(left) + colour(fitted) + ' '.repeat(right) + chalk.cyan(CH.dV);
+        };
+        const titleLine = boxWidth < 48 ? 'VIGTHORIA CLI' : 'VIGTHORIA CLI - AI Coding Assistant';
+        const subtitleLine = boxWidth < 48 ? 'AI Coding Assistant' : `Version ${VERSION}`;
+        const versionLine = boxWidth < 48 ? `Version ${VERSION}` : '';
         console.log(chalk.cyan(CH.dTl + CH.dH.repeat(boxWidth) + CH.dTr));
-        console.log(chalk.cyan(CH.dV + ' '.repeat(boxWidth) + CH.dV));
-        console.log(chalk.cyan(CH.dV) + ' '.repeat(titlePad) + chalk.bold.white('VIGTHORIA CLI') + chalk.cyan(' - AI-Powered Coding Assistant') + ' '.repeat(boxWidth - titlePad - titleText.length) + chalk.cyan(CH.dV));
-        console.log(chalk.cyan(CH.dV) + ' '.repeat(versionPad) + chalk.gray(versionText) + ' '.repeat(boxWidth - versionPad - versionText.length) + chalk.cyan(CH.dV));
-        console.log(chalk.cyan(CH.dV + ' '.repeat(boxWidth) + CH.dV));
+        console.log(center(''));
+        console.log(center(titleLine, (value) => chalk.bold.white(value)));
+        console.log(center(subtitleLine, (value) => chalk.gray(value)));
+        if (versionLine) {
+            console.log(center(versionLine, (value) => chalk.gray(value)));
+        }
+        console.log(center(''));
         console.log(chalk.cyan(CH.dBl + CH.dH.repeat(boxWidth) + CH.dBr));
         console.log();
     }

package/dist/utils/agentRunOutcome.d.ts

@@ -18,6 +18,8 @@ export interface LiveOutcome {
     analysisReadToolsUsed: number;
     /** Final user-facing answer text (stream + response body) */
     answerContent?: string;
+    /** User asked for deep/project-scale analysis, so shallow evidence must not pass. */
+    deepAnalysisRequired?: boolean;
     streamAborted?: boolean;
 }
 export interface TaskSummaryEvent {
@@ -31,7 +33,7 @@ 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. */
+/** Tool-trace stubs like `[read_file] "index.html"` or `<read_file>…</read_file>` — not a user-facing answer. */
 export declare function isToolEvidenceStubAnswer(text: string): boolean;
 /** True when text looks like a real answer, not an executor/system placeholder. */
 export declare function isSubstantiveAgentAnswer(text: string): boolean;

package/dist/utils/agentRunOutcome.js

@@ -17,10 +17,12 @@ export function createLiveOutcome() {
         analysisToolsUsed: 0,
         analysisReadToolsUsed: 0,
         answerContent: '',
+        deepAnalysisRequired: false,
         streamAborted: false,
     };
 }
 const EXECUTOR_PLACEHOLDER_RE = /read-only analysis turn|run at least one discovery tool|reviewing attached files and workspace findings/i;
+const BOOTSTRAP_PLACEHOLDER_RE = /bootstrap discovery completed|inspect the most relevant files next|reviewing attached files and workspace findings/i;
 const LIST_ONLY_DISCOVERY_TOOLS = new Set([
     'list_directory',
     'list_dir',
@@ -28,19 +30,53 @@ const LIST_ONLY_DISCOVERY_TOOLS = new Set([
     'dir',
 ]);
 const GENERIC_SUMMARY_RE = /^(completed the requested analysis|reviewed the workspace without writing changes|task completed|done|finished|analysis completed)([.\s]|$)/i;
-/** Tool-trace stubs like `[read_file] "index.html"` — not a user-facing answer. */
+function looksLikeRawV3EventPayload(text) {
+    const trimmed = String(text || '').trim();
+    if (!/^[{[]/.test(trimmed))
+        return false;
+    try {
+        const parsed = JSON.parse(trimmed);
+        const root = Array.isArray(parsed) ? { events: parsed } : parsed;
+        if (!root || typeof root !== 'object')
+            return false;
+        if (Array.isArray(root.events) && root.events.some((event) => event && typeof event === 'object' && typeof event.type === 'string')) {
+            return true;
+        }
+        return Boolean(root.context_id
+            || root.mcp_context_id
+            || root.workspace_uri
+            || root.execution_surface
+            || root.task_id);
+    }
+    catch {
+        return false;
+    }
+}
+/** Tool-trace stubs like `[read_file] "index.html"` or `<read_file>…</read_file>` — not a user-facing answer. */
 export function isToolEvidenceStubAnswer(text) {
     const trimmed = String(text || '').trim();
     if (!trimmed)
         return true;
+    if (looksLikeRawV3EventPayload(trimmed))
+        return true;
+    if (BOOTSTRAP_PLACEHOLDER_RE.test(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 xmlToolLine = /^<\/?(?:read_file|grep|list_directory|search_files|glob|tool_call|tool_result|path)\b[^>]*>/i;
+    const xmlToolBlockOnly = trimmed
+        .replace(/<read_file>\s*<path>[\s\S]*?<\/path>\s*<\/read_file>/gi, '')
+        .replace(/<(?:grep|list_directory|search_files|glob|tool_call|tool_result)\b[\s\S]*?<\/(?:grep|list_directory|search_files|glob|tool_call|tool_result)>/gi, '')
+        .replace(/\s+/g, '')
+        .trim();
+    if (!xmlToolBlockOnly)
+        return true;
     const filesOnly = /^Files inspected:/i;
-    const stubLines = lines.filter((line) => stubLine.test(line) || filesOnly.test(line)).length;
+    const stubLines = lines.filter((line) => stubLine.test(line) || xmlToolLine.test(line) || filesOnly.test(line)).length;
     if (stubLines === lines.length)
         return true;
     if (stubLines > 0 && stubLines / lines.length >= 0.6 && trimmed.length < 400)
@@ -101,6 +137,7 @@ const READ_DISCOVERY_TOOLS = new Set([
     'grep',
     'list_directory',
     'glob',
+    'search_files',
     'search_project',
     'list_dir',
     'dir',
@@ -171,6 +208,10 @@ export function evaluateExecutorSuccess(liveOutcome) {
         const answerText = normalizeAgentAnswerContent(liveOutcome.answerContent);
         const hasSubstantiveAnswer = isSubstantiveAgentAnswer(answerText);
         const hasDeepRead = liveOutcome.analysisReadToolsUsed > 0;
+        const meetsDeepAnalysisDepth = !liveOutcome.deepAnalysisRequired
+            || (liveOutcome.analysisToolsUsed >= 4
+                && liveOutcome.analysisReadToolsUsed >= 3
+                && answerText.length >= 700);
         if (hasFatalError && !hasSubstantiveAnswer) {
             return {
                 executorSucceeded: false,
@@ -199,6 +240,13 @@ export function evaluateExecutorSuccess(liveOutcome) {
                 uiTheme: 'warning',
             };
         }
+        if (!meetsDeepAnalysisDepth) {
+            return {
+                executorSucceeded: false,
+                statusHeadline: '⚠ Deep analysis was too shallow — retrying needs a project map, multiple file reads, and a structured report',
+                uiTheme: 'warning',
+            };
+        }
         return {
             executorSucceeded: true,
             statusHeadline: '✓ Analysis completed',

package/dist/utils/api.js

@@ -3358,11 +3358,15 @@ document.addEventListener('DOMContentLoaded', () => {
         if (Array.isArray(data?.events)) {
             const completionEvent = [...data.events].reverse().find((event) => event && event.type === 'complete' && typeof event.summary === 'string' && event.summary.trim());
             if (completionEvent) {
-                return sanitizeUserFacingPathText(completionEvent.summary);
+                const text = this.sanitizeV3AgentResponseText(completionEvent.summary);
+                if (isSubstantiveAgentAnswer(text))
+                    return text;
             }
             const messageEvent = [...data.events].reverse().find((event) => event && event.type === 'message' && typeof event.content === 'string' && event.content.trim());
             if (messageEvent) {
-                return this.sanitizeV3AgentResponseText(messageEvent.content);
+                const text = this.sanitizeV3AgentResponseText(messageEvent.content);
+                if (isSubstantiveAgentAnswer(text))
+                    return text;
             }
             // Synthesize a grounded answer from the tool-call evidence the
             // agent produced, rather than dumping the raw event trace.
@@ -3376,8 +3380,7 @@ document.addEventListener('DOMContentLoaded', () => {
             const fileList = Object.keys(data.files).join(', ');
             return `Agent wrote workspace files: ${sanitizeUserFacingPathText(fileList)}`;
         }
-        const text = sanitizeUserFacingPathText(JSON.stringify(data, null, 2));
-        return text.length > 12000 ? `${text.slice(0, 12000)}\n\n[V3 agent output truncated]` : text;
+        return '';
     }
     sanitizeV3AgentResponseText(input) {
         let text = sanitizeUserFacingPathText(String(input || ''));
@@ -3387,6 +3390,9 @@ document.addEventListener('DOMContentLoaded', () => {
             .replace(/<thinking>[\s\S]*?<\/thinking>/gi, '')
             .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
             .replace(/<tool_code>[\s\S]*?<\/tool_code>/gi, '')
+            .replace(/<read_file>\s*<path>[\s\S]*?<\/path>\s*<\/read_file>/gi, '')
+            .replace(/<(?:grep|list_directory|search_files|glob|tool_result)\b[\s\S]*?<\/(?:grep|list_directory|search_files|glob|tool_result)>/gi, '')
+            .replace(/bootstrap discovery completed\s*[—-]\s*inspect the most relevant files next\.?/gi, '')
             .replace(/```json\s*\[\s*\{[\s\S]*?"tool"[\s\S]*?\}\s*\]\s*```/gi, '')
             .replace(/```json\s*\{[\s\S]*?"tool"[\s\S]*?\}\s*```/gi, '')
             .replace(/^\s*(?:json\s*)?\[\s*\{[\s\S]*?"tool"[\s\S]*$/gim, '')

package/dist/utils/logger.js

@@ -162,8 +162,13 @@ export class Logger {
     }
     // Section header
     section(title) {
+        const width = Math.max(24, Number(process.stdout.columns || 80));
+        const cleanTitle = String(title || '').replace(/\s+/g, ' ').trim();
+        const maxTitle = Math.max(10, width - 10);
+        const fittedTitle = cleanTitle.length > maxTitle ? `${cleanTitle.slice(0, maxTitle - 1)}…` : cleanTitle;
+        const side = Math.max(3, Math.floor((Math.min(width, 72) - fittedTitle.length - 2) / 2));
         console.log();
-        console.log(chalk.bold.cyan(`${CH.hDouble.repeat(3)} ${title} ${CH.hDouble.repeat(3)}`));
+        console.log(chalk.bold.cyan(`${CH.hDouble.repeat(side)} ${fittedTitle} ${CH.hDouble.repeat(side)}`));
         console.log();
     }
     // Progress

package/package.json

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