vigthoria-cli 1.11.4 → 1.11.6

package/dist/commands/chat.d.ts

@@ -47,6 +47,7 @@ export declare class ChatCommand {
     private retryPromptSignature;
     private retryPromptStreak;
     private v3SuppressThinkingStream;
+    private v3StreamedAnswerBuffer;
     private lastAgentRunOutcome;
     private isJwtExpirationError;
     private isNetworkError;
@@ -62,6 +63,8 @@ export declare class ChatCommand {
     private getDefaultChatModel;
     private resolveInitialModel;
     private isLegacyAgentFallbackAllowed;
+    private shouldRescueFailedAnalysis;
+    private tryAnalysisLocalRescue;
     private resolveAgentExecutionPolicy;
     private getMessagesForModel;
     private getActivePersonaMode;

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, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
+import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, 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) {
@@ -66,6 +66,7 @@ export class ChatCommand {
     retryPromptSignature = null;
     retryPromptStreak = 0;
     v3SuppressThinkingStream = false;
+    v3StreamedAnswerBuffer = '';
     // Last completed Agent run — used by /retry, /continue, and the final summary block.
     lastAgentRunOutcome = null;
     isJwtExpirationError(error) {
@@ -258,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);
@@ -733,6 +756,7 @@ export class ChatCommand {
             spinner.stop();
         }
         process.stdout.write(safeText);
+        this.v3StreamedAnswerBuffer += safeText;
     }
     sanitizeV3VisibleStreamText(text) {
         let output = String(text || '');
@@ -1965,6 +1989,7 @@ export class ChatCommand {
             qualityMissing: [],
             qualityBlockers: evaluation.executorSucceeded ? [] : [evaluation.statusHeadline],
             hasOutput: liveOutcome.workspaceHasOutput,
+            answerContent: liveOutcome.answerContent || null,
             selfHealStatus: 'skipped',
             selfHealTool: null,
             plannerError: null,
@@ -2453,6 +2478,7 @@ export class ChatCommand {
         this.v3ToolCallCount = 0;
         this.v3LastActivity = Date.now();
         this.v3StreamingStarted = false;
+        this.v3StreamedAnswerBuffer = '';
         const taskDisplay = new TaskDisplay(['Analyse workspace', 'Execute tasks', 'Validate output', 'Self-heal'], !this.jsonOutput);
         taskDisplay.start(0);
         const spinner = this.jsonOutput ? null : createSpinner({
@@ -2637,9 +2663,11 @@ export class ChatCommand {
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
             const changedFileCount = response.changedFiles ? Object.keys(response.changedFiles).length : 0;
             const requiresWorkspaceChanges = this.taskRequiresWorkspaceChanges(prompt);
+            const answerContent = normalizeAgentAnswerContent(response.content, this.v3StreamedAnswerBuffer);
             liveOutcome.changedFileCount = changedFileCount;
             liveOutcome.requiresWorkspaceChanges = requiresWorkspaceChanges;
-            liveOutcome.workspaceHasOutput = workspaceHasOutput;
+            liveOutcome.workspaceHasOutput = requiresWorkspaceChanges ? workspaceHasOutput : false;
+            liveOutcome.answerContent = answerContent;
             const success = previewGate?.required === true
                 ? (previewGate?.passed === true || workspaceHasOutput)
                 : true;
@@ -2683,12 +2711,27 @@ export class ChatCommand {
                     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'}`));
@@ -2723,7 +2766,14 @@ export class ChatCommand {
             let selfHealStatus = null;
             let selfHealTool = null;
             const runEvaluation = evaluateExecutorSuccess(liveOutcome);
-            const executorSucceeded = runEvaluation.executorSucceeded;
+            let executorSucceeded = runEvaluation.executorSucceeded;
+            if (!executorSucceeded && !requiresWorkspaceChanges && !this.jsonOutput) {
+                const rescued = await this.tryAnalysisLocalRescue(prompt, workspacePath);
+                if (rescued) {
+                    watcher?.stop();
+                    return true;
+                }
+            }
             if (!executorSucceeded && requiresWorkspaceChanges && changedFileCount === 0 && !liveOutcome.executorError) {
                 const clientToolErrors = this.api.getClientToolErrors();
                 const transportErrors = this.api.getLastChatTransportErrors();
@@ -2810,6 +2860,7 @@ export class ChatCommand {
                 qualityMissing: liveOutcome.qualityMissing,
                 qualityBlockers: liveOutcome.qualityBlockers,
                 hasOutput: workspaceHasOutput,
+                answerContent: answerContent || null,
                 selfHealStatus,
                 selfHealTool,
                 plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
@@ -2817,7 +2868,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(),
@@ -2837,7 +2888,7 @@ export class ChatCommand {
                     taskId: response.taskId || null,
                     contextId: response.contextId || null,
                     partial: response.partial === true || (!executorSucceeded && liveOutcome.tasksSucceeded > 0),
-                    content: response.content || runEvaluation.statusHeadline,
+                    content: answerContent || response.content || runEvaluation.statusHeadline,
                     statusHeadline: runEvaluation.statusHeadline,
                     tasksSucceeded: liveOutcome.tasksSucceeded,
                     tasksTotal: liveOutcome.tasksTotal,
@@ -2853,7 +2904,7 @@ export class ChatCommand {
                     },
                 }, null, 2));
             }
-            this.messages.push({ role: 'assistant', content: response.content || runEvaluation.statusHeadline });
+            this.messages.push({ role: 'assistant', content: answerContent || response.content || runEvaluation.statusHeadline });
             watcher?.stop();
             return true;
         }
@@ -2907,6 +2958,7 @@ export class ChatCommand {
                 qualityMissing: liveOutcome.qualityMissing,
                 qualityBlockers: liveOutcome.qualityBlockers,
                 hasOutput: this.api.hasAgentWorkspaceOutput(workspaceContext),
+                answerContent: null,
                 selfHealStatus: 'skipped',
                 selfHealTool: null,
                 plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
@@ -3329,14 +3381,20 @@ export class ChatCommand {
                 : `${outcome.tasksSucceeded} task update${outcome.tasksSucceeded === 1 ? '' : 's'} reported`;
             console.log('  ' + chalk.white(taskLine + '.'));
         }
+        else if (outcome.answerContent) {
+            const preview = outcome.answerContent.length > 160
+                ? `${outcome.answerContent.slice(0, 160)}…`
+                : outcome.answerContent;
+            console.log('  ' + chalk.white(`Answer: ${preview}`));
+        }
         else if (changedFileCount > 0) {
-            console.log('  ' + chalk.white(`Workspace changes were produced and are ready for review.`));
+            console.log('  ' + chalk.white('Workspace changes were produced and are ready for review.'));
         }
-        else if (outcome.hasOutput) {
+        else if (outcome.hasOutput && executorSucceeded && changedFileCount === 0) {
             console.log('  ' + chalk.white('The assistant returned a final answer for your request.'));
         }
         else {
-            console.log('  ' + chalk.white('No final workspace output was confirmed.'));
+            console.log('  ' + chalk.white('No final answer or workspace output was confirmed.'));
         }
         if (outcome.selfHealStatus && outcome.selfHealStatus !== 'skipped') {
             console.log('  ' + chalk.white(`Self-check status: ${outcome.selfHealStatus}.`));

package/dist/index.js

@@ -75,8 +75,41 @@ function getPackageMetadataPaths() {
         path.join(process.env.APPDATA || '', 'npm', 'node_modules', 'vigthoria-cli', 'package.json'),
     ];
 }
+function resolveRunningPackageJsonPath() {
+    const candidates = [];
+    const scriptArg = process.argv[1];
+    if (scriptArg) {
+        try {
+            const resolvedScript = fs.realpathSync(scriptArg);
+            candidates.push(path.join(path.dirname(resolvedScript), '..', 'package.json'));
+        }
+        catch {
+            candidates.push(path.join(path.dirname(scriptArg), '..', 'package.json'));
+        }
+    }
+    candidates.push(path.join(__dirname, '..', 'package.json'));
+    for (const candidate of candidates) {
+        try {
+            if (!fs.existsSync(candidate))
+                continue;
+            const pkg = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+            if (pkg?.name === 'vigthoria-cli')
+                return candidate;
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
 function getVersion() {
     try {
+        const runningPackageJson = resolveRunningPackageJsonPath();
+        if (runningPackageJson) {
+            const pkg = JSON.parse(fs.readFileSync(runningPackageJson, 'utf8'));
+            if (pkg.version)
+                return pkg.version;
+        }
         for (const p of getPackageMetadataPaths()) {
             if (fs.existsSync(p)) {
                 const pkg = JSON.parse(fs.readFileSync(p, 'utf8'));
@@ -149,6 +182,30 @@ function compareVersions(v1, v2) {
     }
     return 0;
 }
+function maxVersion(...versions) {
+    let best = null;
+    for (const version of versions) {
+        if (!version)
+            continue;
+        if (!best || compareVersions(version, best) > 0)
+            best = version;
+    }
+    return best;
+}
+async function fetchNpmLatestVersion() {
+    const { execSync } = await import('child_process');
+    try {
+        const latest = execSync('npm view vigthoria-cli version', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        }).trim();
+        return latest || null;
+    }
+    catch {
+        return null;
+    }
+}
 const VERSION = getVersion();
 const VIGTHORIA_DEFAULT_MANIFEST_URL = process.env.VIGTHORIA_UPDATE_MANIFEST_URL || "https://coder.vigthoria.io/releases/manifest.json";
 function resolveManifestEntry(manifest, channel) {
@@ -1452,7 +1509,6 @@ 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 } = 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';
@@ -1484,11 +1540,13 @@ Examples:
                 return;
             }
         }
+        if (isOfflineMode()) {
+            console.log(chalk.yellow('Offline mode (VIGTHORIA_OFFLINE=1): skipping update check.'));
+            return;
+        }
+        const currentVersion = VERSION;
+        let manifestEntry = null;
         if (manifestUrl) {
-            if (isOfflineMode()) {
-                console.log(chalk.yellow('Offline mode (VIGTHORIA_OFFLINE=1): skipping manifest update.'));
-                return;
-            }
             try {
                 console.log(chalk.cyan(`Checking manifest channel ${channel}...`));
                 const response = await axios.get(manifestUrl, {
@@ -1496,103 +1554,96 @@ Examples:
                     maxRedirects: 5,
                     validateStatus: (status) => status >= 200 && status < 300,
                 });
-                const entry = resolveManifestEntry(response.data || {}, channel);
-                if (!entry || !entry.version || !entry.url) {
-                    console.error(chalk.red(`Manifest missing valid release entry for channel: ${channel}`));
-                    console.log(chalk.gray('Expected: channels.<channel>.version and channels.<channel>.url'));
-                    process.exitCode = 1;
-                    return;
-                }
-                const currentVersion = VERSION;
-                const comparison = compareVersions(entry.version, currentVersion);
-                if (!allowDowngrade && comparison <= 0) {
-                    console.log(chalk.green(`You are running the latest version for channel ${channel} (${currentVersion})`));
-                    return;
-                }
-                console.log(chalk.yellow(`Update available from manifest: ${currentVersion} -> ${entry.version} (${channel})`));
-                if (entry.notes) {
-                    console.log(chalk.gray(`   ${entry.notes}`));
-                }
-                if (options.check) {
-                    console.log(chalk.gray(`Install with: vigthoria update --manifest ${manifestUrl} --channel ${channel}`));
-                    return;
-                }
-                const tmpFile = path.join(os.tmpdir(), `vigthoria-update-${Date.now()}.tgz`);
-                try {
-                    console.log(chalk.cyan('Downloading release package...'));
-                    await downloadFile(entry.url, tmpFile);
-                    if (entry.sha256) {
-                        const expected = entry.sha256.toLowerCase();
-                        const actual = sha256File(tmpFile).toLowerCase();
-                        if (actual !== expected) {
-                            console.error(chalk.red('Release checksum verification failed'));
-                            console.error(chalk.red(`Expected: ${expected}`));
-                            console.error(chalk.red(`Actual:   ${actual}`));
-                            process.exitCode = 1;
-                            return;
-                        }
-                        console.log(chalk.green('Checksum verification passed'));
-                    }
-                    else {
-                        console.log(chalk.yellow.bold('WARNING: manifest entry has no sha256.'));
-                        console.log(chalk.yellow('   The release artifact will be installed without integrity verification.'));
-                        console.log(chalk.gray('   Set --manifest to a trusted source, or supply sha256 in the manifest entry.'));
-                    }
-                    console.log(chalk.cyan('Installing update...'));
-                    await installGlobalPackageWithNpm(tmpFile);
-                    console.log(chalk.green(`Updated to version ${entry.version}`));
-                    console.log(chalk.gray('Please restart the CLI to use the new version'));
-                    return;
-                }
-                finally {
-                    if (fs.existsSync(tmpFile)) {
-                        try {
-                            fs.unlinkSync(tmpFile);
-                        }
-                        catch { }
-                    }
+                manifestEntry = resolveManifestEntry(response.data || {}, channel);
+                if (!manifestEntry?.version || !manifestEntry?.url) {
+                    console.log(chalk.yellow(`Manifest has no installable entry for channel ${channel}; will check npm.`));
+                    manifestEntry = null;
                 }
             }
             catch (error) {
-                console.error(chalk.red('Failed to process manifest update:'), error.message);
-                console.log(chalk.gray('Falling back to npm/git update channels...'));
+                console.log(chalk.yellow(`Manifest check failed: ${error.message}`));
+                console.log(chalk.gray('Continuing with npm registry check...'));
             }
         }
-        if (isOfflineMode()) {
-            console.log(chalk.yellow('Offline mode (VIGTHORIA_OFFLINE=1): skipping update check.'));
+        console.log(chalk.cyan('Checking npm registry...'));
+        const npmVersion = await fetchNpmLatestVersion();
+        if (!npmVersion) {
+            console.log(chalk.yellow('Could not read latest version from npm registry.'));
+        }
+        const effectiveLatest = maxVersion(manifestEntry?.version, npmVersion);
+        if (!effectiveLatest) {
+            console.error(chalk.red('Unable to determine the latest CLI version from manifest or npm.'));
+            process.exitCode = 1;
             return;
         }
-        console.log(chalk.cyan('Checking for updates...'));
-        try {
-            // Get latest version from npm - cross-platform
-            const latestVersion = execSync('npm view vigthoria-cli version', {
-                encoding: 'utf8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-                windowsHide: true,
-            }).trim();
-            const currentVersion = VERSION;
-            // Use semantic version comparison (1.6.0 > 1.5.9)
-            const comparison = compareVersions(latestVersion, currentVersion);
-            if (comparison <= 0) {
-                console.log(chalk.green(`You are running the latest version (${currentVersion})`));
+        if (manifestEntry?.version
+            && npmVersion
+            && compareVersions(npmVersion, manifestEntry.version) > 0) {
+            console.log(chalk.yellow(`Release manifest (${manifestEntry.version}) is behind npm (${npmVersion}); npm will be used when needed.`));
+        }
+        if (!allowDowngrade && compareVersions(effectiveLatest, currentVersion) <= 0) {
+            console.log(chalk.green(`You are running the latest version (${currentVersion})`));
+            return;
+        }
+        console.log(chalk.yellow(`Update available: ${currentVersion} -> ${effectiveLatest}`));
+        if (manifestEntry?.notes && compareVersions(manifestEntry.version, effectiveLatest) >= 0) {
+            console.log(chalk.gray(`   ${manifestEntry.notes}`));
+        }
+        if (options.check) {
+            console.log(chalk.gray('Run `vigthoria update` to install the update'));
+            return;
+        }
+        const manifestIsAuthoritative = Boolean(manifestEntry
+            && manifestEntry.url
+            && compareVersions(manifestEntry.version, effectiveLatest) >= 0
+            && compareVersions(manifestEntry.version, currentVersion) > 0);
+        if (manifestIsAuthoritative && manifestEntry) {
+            const tmpFile = path.join(os.tmpdir(), `vigthoria-update-${Date.now()}.tgz`);
+            try {
+                console.log(chalk.cyan(`Downloading release package (${manifestEntry.version})...`));
+                await downloadFile(manifestEntry.url, tmpFile);
+                if (manifestEntry.sha256) {
+                    const expected = manifestEntry.sha256.toLowerCase();
+                    const actual = sha256File(tmpFile).toLowerCase();
+                    if (actual !== expected) {
+                        console.error(chalk.red('Release checksum verification failed'));
+                        console.error(chalk.red(`Expected: ${expected}`));
+                        console.error(chalk.red(`Actual:   ${actual}`));
+                        process.exitCode = 1;
+                        return;
+                    }
+                    console.log(chalk.green('Checksum verification passed'));
+                }
+                else {
+                    console.log(chalk.yellow.bold('WARNING: manifest entry has no sha256.'));
+                    console.log(chalk.yellow('   The release artifact will be installed without integrity verification.'));
+                }
+                console.log(chalk.cyan('Installing update...'));
+                await installGlobalPackageWithNpm(tmpFile);
+                console.log(chalk.green(`Updated to version ${manifestEntry.version}`));
+                console.log(chalk.gray('Please restart the CLI to use the new version'));
                 return;
             }
-            console.log(chalk.yellow(`Update available: ${currentVersion} -> ${latestVersion}`));
-            if (options.check) {
-                console.log(chalk.gray('Run `vigthoria update` to install the update'));
-                return;
+            finally {
+                if (fs.existsSync(tmpFile)) {
+                    try {
+                        fs.unlinkSync(tmpFile);
+                    }
+                    catch { }
+                }
             }
-            console.log(chalk.cyan('Installing update from npm registry...'));
-            await installGlobalPackageWithNpm('vigthoria-cli@latest');
-            console.log(chalk.green(`Updated to version ${latestVersion}`));
+        }
+        const npmSpec = npmVersion && compareVersions(npmVersion, currentVersion) > 0
+            ? `vigthoria-cli@${npmVersion}`
+            : 'vigthoria-cli@latest';
+        try {
+            console.log(chalk.cyan(`Installing update from npm registry (${npmSpec})...`));
+            await installGlobalPackageWithNpm(npmSpec);
+            console.log(chalk.green(`Updated to version ${effectiveLatest}`));
             console.log(chalk.gray('Please restart the CLI to use the new version'));
         }
         catch (error) {
-            console.error(chalk.red('Failed to check/install via npm registry:'), error.message);
-            if (options.check) {
-                console.log(chalk.gray(`npm registry check failed; fallback install target is ${gitPackageSpec}`));
-                return;
-            }
+            console.error(chalk.red('Failed to install via npm registry:'), error.message);
             try {
                 console.log(chalk.cyan('Attempting git package fallback...'));
                 await installGlobalPackageWithNpm(gitPackageSpec);
@@ -1601,7 +1652,7 @@ Examples:
             }
             catch (fallbackError) {
                 console.error(chalk.red('Fallback update also failed:'), fallbackError.message);
-                console.log(chalk.gray('Try manually: npm install -g vigthoria-cli@latest'));
+                console.log(chalk.gray(`Try manually: npm install -g ${npmSpec}`));
                 console.log(chalk.gray(`Or: npm install -g ${gitPackageSpec}`));
                 process.exitCode = 1;
             }

package/dist/utils/agentRunOutcome.d.ts

@@ -14,6 +14,10 @@ export interface LiveOutcome {
     failedTaskIds: Set<string>;
     completedTaskIds: Set<string>;
     analysisToolsUsed: number;
+    /** read_file / grep — not list_directory-only browsing */
+    analysisReadToolsUsed: number;
+    /** Final user-facing answer text (stream + response body) */
+    answerContent?: string;
     streamAborted?: boolean;
 }
 export interface TaskSummaryEvent {
@@ -27,6 +31,10 @@ export interface RunEvaluation {
     uiTheme: 'success' | 'warning' | 'error';
 }
 export declare function createLiveOutcome(): LiveOutcome;
+/** 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. */
+export declare function normalizeAgentAnswerContent(...sources: Array<string | undefined | null>): string;
 /** Process executor_complete / task summary events from the V3 SSE stream. */
 export declare function handleTaskEvent(summary: TaskSummaryEvent, liveOutcome: LiveOutcome): void;
 /** Track read/discovery tool usage for analysis-turn accountability. */

package/dist/utils/agentRunOutcome.js

@@ -15,9 +15,38 @@ export function createLiveOutcome() {
         failedTaskIds: new Set(),
         completedTaskIds: new Set(),
         analysisToolsUsed: 0,
+        analysisReadToolsUsed: 0,
+        answerContent: '',
         streamAborted: false,
     };
 }
+const EXECUTOR_PLACEHOLDER_RE = /read-only analysis turn|run at least one discovery tool|reviewing attached files and workspace findings/i;
+const LIST_ONLY_DISCOVERY_TOOLS = new Set([
+    'list_directory',
+    'list_dir',
+    'glob',
+    'dir',
+]);
+/** 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)
+        return false;
+    if (EXECUTOR_PLACEHOLDER_RE.test(trimmed))
+        return false;
+    if (/^v3 agent workflow completed\.?$/i.test(trimmed))
+        return false;
+    return true;
+}
+/** Pick the first substantive answer from response body and/or streamed text. */
+export function normalizeAgentAnswerContent(...sources) {
+    for (const source of sources) {
+        const text = String(source || '').trim();
+        if (isSubstantiveAgentAnswer(text))
+            return text;
+    }
+    return '';
+}
 /** Process executor_complete / task summary events from the V3 SSE stream. */
 export function handleTaskEvent(summary, liveOutcome) {
     const tid = summary.task_id || summary.id;
@@ -60,6 +89,9 @@ export function noteAnalysisToolUse(toolName, liveOutcome) {
     const normalized = String(toolName || '').trim().toLowerCase();
     if (READ_DISCOVERY_TOOLS.has(normalized)) {
         liveOutcome.analysisToolsUsed += 1;
+        if (!LIST_ONLY_DISCOVERY_TOOLS.has(normalized)) {
+            liveOutcome.analysisReadToolsUsed += 1;
+        }
     }
 }
 /**
@@ -114,21 +146,37 @@ export function evaluateExecutorSuccess(liveOutcome) {
     }
     // Analysis / verification turns with no planned task graph
     if (!liveOutcome.requiresWorkspaceChanges) {
-        const analysisOk = liveOutcome.analysisToolsUsed > 0 || liveOutcome.workspaceHasOutput;
-        if (!analysisOk && hasFatalError) {
+        const answerText = normalizeAgentAnswerContent(liveOutcome.answerContent);
+        const hasSubstantiveAnswer = isSubstantiveAgentAnswer(answerText);
+        const hasDeepRead = liveOutcome.analysisReadToolsUsed > 0;
+        if (hasFatalError && !hasSubstantiveAnswer) {
             return {
                 executorSucceeded: false,
-                statusHeadline: '✕ Analysis failed — no workspace evidence gathered',
+                statusHeadline: '✕ Analysis failed — no answer produced',
                 uiTheme: 'error',
             };
         }
-        if (!analysisOk) {
+        if (!hasSubstantiveAnswer) {
+            if (liveOutcome.analysisToolsUsed > 0) {
+                return {
+                    executorSucceeded: false,
+                    statusHeadline: '⚠ Analysis browsed the workspace but did not answer your question — try /retry',
+                    uiTheme: 'warning',
+                };
+            }
             return {
                 executorSucceeded: false,
                 statusHeadline: '⚠ Warning: No read tools confirmed — answer may be incomplete',
                 uiTheme: 'warning',
             };
         }
+        if (!hasDeepRead) {
+            return {
+                executorSucceeded: false,
+                statusHeadline: '⚠ Analysis answer was not verified against source files — try /retry',
+                uiTheme: 'warning',
+            };
+        }
         return {
             executorSucceeded: true,
             statusHeadline: '✓ Analysis completed',

package/dist/utils/api.js

@@ -11,6 +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';
 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 {
@@ -2744,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))
@@ -2757,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');
@@ -2804,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);
             }
@@ -3308,13 +3341,19 @@ document.addEventListener('DOMContentLoaded', () => {
     formatV3AgentResponse(data) {
         const result = data?.result || {};
         if (typeof result === 'string') {
-            return this.sanitizeV3AgentResponseText(result);
+            const text = this.sanitizeV3AgentResponseText(result);
+            if (isSubstantiveAgentAnswer(text))
+                return text;
         }
         if (typeof result?.summary === 'string' && result.summary.trim()) {
-            return this.sanitizeV3AgentResponseText(result.summary);
+            const text = this.sanitizeV3AgentResponseText(result.summary);
+            if (isSubstantiveAgentAnswer(text))
+                return text;
         }
         if (typeof result?.message === 'string' && result.message.trim()) {
-            return this.sanitizeV3AgentResponseText(result.message);
+            const text = this.sanitizeV3AgentResponseText(result.message);
+            if (isSubstantiveAgentAnswer(text))
+                return text;
         }
         if (Array.isArray(data?.events)) {
             const completionEvent = [...data.events].reverse().find((event) => event && event.type === 'complete' && typeof event.summary === 'string' && event.summary.trim());
@@ -3639,6 +3678,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.4",
+  "version": "1.11.6",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",