vigthoria-cli 1.11.3 → 1.11.5

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;
@@ -149,6 +150,8 @@ export declare class ChatCommand {
     private runOperatorDirectAnswer;
     private runSimplePrompt;
     private runAgentTurn;
+    private buildLocalLoopLiveOutcome;
+    private persistLocalLoopOutcome;
     private runLocalAgentLoop;
     private primeBypassedTargetFileContext;
     private tryDirectSingleFileFlow;

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) {
@@ -733,6 +734,7 @@ export class ChatCommand {
             spinner.stop();
         }
         process.stdout.write(safeText);
+        this.v3StreamedAnswerBuffer += safeText;
     }
     sanitizeV3VisibleStreamText(text) {
         let output = String(text || '');
@@ -1940,6 +1942,43 @@ export class ChatCommand {
         }
         await this.runLocalAgentLoop(prompt);
     }
+    buildLocalLoopLiveOutcome(prompt) {
+        const liveOutcome = createLiveOutcome();
+        liveOutcome.requiresWorkspaceChanges = this.taskRequiresWorkspaceChanges(prompt);
+        liveOutcome.analysisToolsUsed = this.agentToolEvidence.discovery;
+        liveOutcome.changedFileCount = this.agentToolEvidence.mutation;
+        liveOutcome.workspaceHasOutput = this.agentToolEvidence.mutation > 0;
+        if (this.agentToolEvidence.searchFailed > 0 && this.agentToolEvidence.discovery === 0) {
+            liveOutcome.executorFailed = true;
+            liveOutcome.executorError = 'Search tools failed before gathering workspace evidence';
+        }
+        return liveOutcome;
+    }
+    persistLocalLoopOutcome(prompt, evaluation, liveOutcome) {
+        this.lastAgentRunOutcome = {
+            prompt,
+            taskId: null,
+            contextId: null,
+            tasksSucceeded: liveOutcome.tasksSucceeded,
+            tasksTotal: liveOutcome.tasksTotal,
+            failedTaskIds: [...liveOutcome.failedTaskIds],
+            unfinishedTaskIds: [],
+            qualityScore: null,
+            qualityMissing: [],
+            qualityBlockers: evaluation.executorSucceeded ? [] : [evaluation.statusHeadline],
+            hasOutput: liveOutcome.workspaceHasOutput,
+            answerContent: liveOutcome.answerContent || null,
+            selfHealStatus: 'skipped',
+            selfHealTool: null,
+            plannerError: null,
+            executorError: liveOutcome.executorError,
+            clientToolErrors: [],
+            transportErrors: [],
+            workspacePath: this.currentProjectPath || null,
+            workspaceSyncIssue: null,
+            finishedAt: Date.now(),
+        };
+    }
     async runLocalAgentLoop(prompt) {
         if (!this.tools) {
             throw new Error('Agent tools are not initialized.');
@@ -1975,14 +2014,26 @@ export class ChatCommand {
                         const evidenceSummary = this.synthesizeEvidenceFromHistory();
                         if (evidenceSummary) {
                             const fallbackContent = this.sanitizeDirectModeOutput(evidenceSummary);
+                            const liveOutcome = this.buildLocalLoopLiveOutcome(prompt);
+                            const evaluation = evaluateExecutorSuccess(liveOutcome);
+                            this.persistLocalLoopOutcome(prompt, evaluation, liveOutcome);
                             if (this.jsonOutput) {
+                                process.exitCode = evaluation.executorSucceeded ? 0 : 1;
                                 console.log(JSON.stringify({
-                                    success: true,
+                                    success: evaluation.executorSucceeded,
                                     mode: 'agent',
                                     model: this.currentModel,
-                                    partial: true,
+                                    partial: !evaluation.executorSucceeded,
                                     content: fallbackContent,
-                                    metadata: { executionPath: 'local-agent-loop', recovered: true },
+                                    statusHeadline: evaluation.statusHeadline,
+                                    metadata: {
+                                        executionPath: 'local-agent-loop',
+                                        recovered: true,
+                                        outcomeTruth: {
+                                            executorSucceeded: evaluation.executorSucceeded,
+                                            uiTheme: evaluation.uiTheme,
+                                        },
+                                    },
                                 }, null, 2));
                             }
                             else {
@@ -2078,15 +2129,26 @@ export class ChatCommand {
                         continue;
                     }
                     const finalContent = this.resolveDirectModeCompletion(prompt, visibleText);
+                    const liveOutcome = this.buildLocalLoopLiveOutcome(prompt);
+                    const evaluation = evaluateExecutorSuccess(liveOutcome);
+                    this.persistLocalLoopOutcome(prompt, evaluation, liveOutcome);
                     if (this.jsonOutput) {
+                        process.exitCode = evaluation.executorSucceeded ? 0 : 1;
                         console.log(JSON.stringify({
-                            success: true,
+                            success: evaluation.executorSucceeded,
                             mode: 'agent',
                             model: this.currentModel,
-                            partial: false,
+                            partial: !evaluation.executorSucceeded,
                             content: finalContent,
+                            statusHeadline: evaluation.statusHeadline,
                             metadata: {
                                 executionPath: 'local-agent-loop',
+                                outcomeTruth: {
+                                    executorSucceeded: evaluation.executorSucceeded,
+                                    uiTheme: evaluation.uiTheme,
+                                    analysisToolsUsed: liveOutcome.analysisToolsUsed,
+                                    changedFileCount: liveOutcome.changedFileCount,
+                                },
                             },
                         }, null, 2));
                     }
@@ -2131,6 +2193,13 @@ export class ChatCommand {
                 return;
             }
         }
+        const liveOutcome = this.buildLocalLoopLiveOutcome(prompt);
+        const exhaustedEval = evaluateExecutorSuccess({
+            ...liveOutcome,
+            executorFailed: true,
+            executorError: 'Agent exhausted the maximum local tool loop turns before reaching a clean completion.',
+        });
+        this.persistLocalLoopOutcome(prompt, exhaustedEval, liveOutcome);
         if (this.jsonOutput) {
             process.exitCode = 1;
             console.log(JSON.stringify({
@@ -2140,8 +2209,13 @@ export class ChatCommand {
                 partial: true,
                 content: 'Task complete.',
                 error: 'Agent exhausted the maximum local tool loop turns before reaching a clean completion.',
+                statusHeadline: exhaustedEval.statusHeadline,
                 metadata: {
                     executionPath: 'local-agent-loop',
+                    outcomeTruth: {
+                        executorSucceeded: false,
+                        uiTheme: exhaustedEval.uiTheme,
+                    },
                 },
             }, null, 2));
         }
@@ -2382,6 +2456,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({
@@ -2566,9 +2641,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;
@@ -2612,12 +2689,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'}`));
@@ -2739,6 +2831,7 @@ export class ChatCommand {
                 qualityMissing: liveOutcome.qualityMissing,
                 qualityBlockers: liveOutcome.qualityBlockers,
                 hasOutput: workspaceHasOutput,
+                answerContent: answerContent || null,
                 selfHealStatus,
                 selfHealTool,
                 plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
@@ -2766,7 +2859,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,
@@ -2782,7 +2875,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;
         }
@@ -2836,6 +2929,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,
@@ -3258,14 +3352,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 {
@@ -3308,13 +3309,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());

package/package.json

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