vigthoria-cli 1.9.19 → 1.9.20

package/dist/commands/chat.d.ts

@@ -40,6 +40,7 @@ export declare class ChatCommand {
     private savePlanToVigFlow;
     private jsonOutput;
     private modelGovernanceFallback;
+    private lastAgentRunOutcome;
     private isJwtExpirationError;
     private isNetworkError;
     private isTimeoutError;
@@ -140,6 +141,29 @@ export declare class ChatCommand {
     private tryRecoverV3ServiceAndRetry;
     private startInteractiveChat;
     private showHelp;
+    /**
+     * Print a clear, opinionated end-of-run summary after every agent workflow.
+     *
+     * Goals:
+     *   - User can answer "Did it succeed?" in one glance.
+     *   - User can answer "What do I type next?" without reading 200 scrollback lines.
+     *   - Never leave the spinners (`⟳`, `–`) ambiguous when the prompt returns.
+     */
+    private printAgentRunSummary;
+    /**
+     * Build the prompt sent to the agent when the user types `/retry`.
+     * Resumes only the failed/unfinished tasks from the previous run.
+     */
+    private buildRetryPrompt;
+    /**
+     * Build the prompt sent to the agent when the user types `/continue`.
+     * Tells the agent to keep working from the current workspace state.
+     */
+    private buildContinuePrompt;
+    /**
+     * Re-print the last agent run summary, or guide the user when there isn't one.
+     */
+    private showAgentRunStatus;
     private showContext;
     private showProjectMemory;
     private compactCurrentSession;

package/dist/commands/chat.js

@@ -59,6 +59,8 @@ export class ChatCommand {
     savePlanToVigFlow = false;
     jsonOutput = false;
     modelGovernanceFallback = null;
+    // Last completed Agent run — used by /retry, /continue, and the final summary block.
+    lastAgentRunOutcome = null;
     isJwtExpirationError(error) {
         const candidate = error;
         const message = `${candidate?.message || ''} ${typeof candidate?.details === 'string' ? candidate.details : ''}`.toLowerCase();
@@ -1934,6 +1936,60 @@ export class ChatCommand {
             text: routingPolicy.cloudSelected ? 'Routing heavy task to Vigthoria Cloud...' : 'Routing to V3 Agent...',
             spinner: 'clock',
         }).start();
+        // Live run telemetry, used both for the final summary block and for /retry, /continue.
+        const liveOutcome = {
+            tasksSucceeded: 0,
+            tasksTotal: 0,
+            failedTaskIds: new Set(),
+            unfinishedTaskIds: new Set(),
+            qualityScore: null,
+            qualityMissing: [],
+            qualityBlockers: [],
+            plannerError: null,
+            executorError: null,
+            executorFailed: false,
+        };
+        const parsePlannerSummary = (raw) => {
+            if (!raw || typeof raw !== 'string')
+                return;
+            const succ = raw.match(/(\d+)\s*\/\s*(\d+)\s+tasks?\s+succeeded/i);
+            if (succ) {
+                liveOutcome.tasksSucceeded = Number(succ[1]) || 0;
+                liveOutcome.tasksTotal = Number(succ[2]) || 0;
+            }
+            const failed = raw.match(/Failed\s+tasks?:\s*([^.\n]+)/i);
+            if (failed) {
+                failed[1].split(/[,\s]+/).map(s => s.trim()).filter(Boolean)
+                    .forEach(t => liveOutcome.failedTaskIds.add(t));
+            }
+            const unfinished = raw.match(/Unfinished\s+tasks?:\s*([^.\n]+)/i);
+            if (unfinished) {
+                unfinished[1].split(/[,\s]+/).map(s => s.trim()).filter(Boolean)
+                    .forEach(t => liveOutcome.unfinishedTaskIds.add(t));
+            }
+            const qScore = raw.match(/Quality\s+audit:\s*([0-9.]+)\s*\/\s*100/i);
+            if (qScore) {
+                const n = Number(qScore[1]);
+                if (Number.isFinite(n))
+                    liveOutcome.qualityScore = n;
+            }
+            const blockers = raw.match(/Quality\s+blockers?:\s*([^\n]+?)(?:\s+Quality\s+audit|$)/i);
+            if (blockers) {
+                blockers[1].split(/;/).map(s => s.trim()).filter(Boolean)
+                    .forEach(b => {
+                    if (!liveOutcome.qualityBlockers.includes(b))
+                        liveOutcome.qualityBlockers.push(b);
+                });
+            }
+            const missingFeatures = raw.match(/Missing\s+features?:\s*([^\n]+)/i);
+            if (missingFeatures) {
+                missingFeatures[1].split(/[,;]/).map(s => s.trim()).filter(Boolean)
+                    .forEach(m => {
+                    if (!liveOutcome.qualityMissing.includes(m))
+                        liveOutcome.qualityMissing.push(m);
+                });
+            }
+        };
         const executionPrompt = this.buildExecutionPrompt(contextualPrompt);
         const agentTaskType = this.inferAgentTaskType(contextualPrompt);
         const workspaceContext = {
@@ -1976,10 +2032,45 @@ export class ChatCommand {
                     if (event.type === 'plan') {
                         taskDisplay.complete(0);
                         taskDisplay.start(1);
+                        const tasks = event?.plan?.tasks;
+                        if (Array.isArray(tasks))
+                            liveOutcome.tasksTotal = tasks.length;
                     }
                     else if (event.type === 'executor_start') {
                         taskDisplay.start(1);
                     }
+                    else if (event.type === 'executor_complete') {
+                        const summary = event.summary || {};
+                        const tid = summary.task_id || summary.id;
+                        if (summary.status === 'failed') {
+                            if (tid)
+                                liveOutcome.failedTaskIds.add(String(tid));
+                            liveOutcome.executorFailed = true;
+                        }
+                        else if (summary.status === 'completed' || summary.status === 'success') {
+                            if (tid)
+                                liveOutcome.failedTaskIds.delete(String(tid));
+                            liveOutcome.tasksSucceeded += 1;
+                        }
+                    }
+                    else if (event.type === 'executor_error') {
+                        const msg = typeof event.error === 'string' ? event.error : '';
+                        if (msg)
+                            liveOutcome.executorError = msg;
+                    }
+                    else if (event.type === 'error') {
+                        const msg = typeof event.message === 'string' ? event.message : '';
+                        if (/plan|planner|dependency graph/i.test(msg)) {
+                            if (!liveOutcome.plannerError)
+                                liveOutcome.plannerError = msg;
+                            parsePlannerSummary(msg);
+                        }
+                        else if (/executor|task failed|iteration/i.test(msg)) {
+                            if (!liveOutcome.executorError)
+                                liveOutcome.executorError = msg;
+                            parsePlannerSummary(msg);
+                        }
+                    }
                     else if (event.type === 'complete') {
                         taskDisplay.complete(1);
                     }
@@ -2087,8 +2178,26 @@ export class ChatCommand {
                     console.log(chalk.gray(`Run ${chalk.cyan('vigthoria preview --diff')} for full visual diffs.`));
                 }
             }
+            // Resolve the Execute-tasks spinner: only mark it ✓ when the run actually
+            // produced real, validated output. Otherwise the user just saw a wall of
+            // executor errors and the spinner needs to clearly say "failed", not "✓".
+            let selfHealStatus = null;
+            let selfHealTool = null;
+            const executorSucceeded = !liveOutcome.executorFailed
+                && !liveOutcome.plannerError
+                && !liveOutcome.executorError
+                && workspaceHasOutput;
+            if (executorSucceeded) {
+                taskDisplay.complete(1);
+            }
+            else {
+                const failDetail = liveOutcome.failedTaskIds.size > 0
+                    ? `failed: ${[...liveOutcome.failedTaskIds].slice(0, 4).join(', ')}`
+                    : (liveOutcome.executorError ? 'executor error' : (liveOutcome.plannerError ? 'planner error' : 'incomplete'));
+                taskDisplay.fail(1, failDetail);
+            }
             // ── Self-healing validation ──────────────────────────────────────
-            if (this.currentProjectPath && !this.jsonOutput && success) {
+            if (this.currentProjectPath && !this.jsonOutput && success && executorSucceeded) {
                 try {
                     taskDisplay.start(2, 'validating...');
                     const healResult = await this.api.runSelfHealingCycle(executionPrompt, this.currentProjectPath, workspaceContext);
@@ -2096,10 +2205,13 @@ export class ChatCommand {
                         taskDisplay.complete(2);
                         if (healResult.passed) {
                             taskDisplay.complete(3);
+                            selfHealStatus = 'passed';
                         }
                         else {
                             taskDisplay.fail(3, healResult.tool);
+                            selfHealStatus = 'partial';
                         }
+                        selfHealTool = healResult.tool || null;
                         if (!this.directPromptMode) {
                             const hs = healResult.passed ? chalk.green('passed') : chalk.yellow('partial');
                             console.log(chalk.gray(`Self-healing: ${hs} (${healResult.tool})`));
@@ -2108,20 +2220,45 @@ export class ChatCommand {
                     else {
                         taskDisplay.skip(2);
                         taskDisplay.skip(3);
+                        selfHealStatus = 'skipped';
                     }
                 }
                 catch (error) {
                     this.logger.debug(`Self-healing validation failed: ${error instanceof Error ? error.message : String(error)}`);
                     taskDisplay.skip(2);
                     taskDisplay.skip(3);
+                    selfHealStatus = 'failed';
                 }
             }
             else {
                 taskDisplay.skip(2);
                 taskDisplay.skip(3);
+                selfHealStatus = 'skipped';
             }
             taskDisplay.finalize();
             // ────────────────────────────────────────────────────────────────
+            this.lastAgentRunOutcome = {
+                prompt,
+                taskId: response.taskId || null,
+                contextId: response.contextId || null,
+                tasksSucceeded: liveOutcome.tasksSucceeded,
+                tasksTotal: liveOutcome.tasksTotal,
+                failedTaskIds: [...liveOutcome.failedTaskIds],
+                unfinishedTaskIds: [...liveOutcome.unfinishedTaskIds],
+                qualityScore: liveOutcome.qualityScore,
+                qualityMissing: liveOutcome.qualityMissing,
+                qualityBlockers: liveOutcome.qualityBlockers,
+                hasOutput: workspaceHasOutput,
+                selfHealStatus,
+                selfHealTool,
+                plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
+                executorError: liveOutcome.executorError ? sanitizeUserFacingErrorText(liveOutcome.executorError) : null,
+                finishedAt: Date.now(),
+            };
+            if (!this.jsonOutput && !this.directPromptMode) {
+                const changedFileCount = response.changedFiles ? Object.keys(response.changedFiles).length : 0;
+                this.printAgentRunSummary(this.lastAgentRunOutcome, executorSucceeded, changedFileCount);
+            }
             this.messages.push({ role: 'assistant', content: response.content || 'V3 agent workflow completed.' });
             watcher?.stop();
             return true;
@@ -2151,6 +2288,33 @@ export class ChatCommand {
                 : 'Agent mode is unavailable right now. Please retry shortly or run vigthoria login if the issue persists.';
             this.logger.error(errorMessage);
             this.messages.push({ role: 'assistant', content: errorMessage });
+            // Resolve any half-rendered TaskDisplay spinners before the prompt
+            // comes back, otherwise the user sees `⟳ Execute tasks` next to `>`.
+            try {
+                taskDisplay.fail(1, 'agent unavailable');
+                taskDisplay.skip(2);
+                taskDisplay.skip(3);
+                taskDisplay.finalize();
+            }
+            catch (_) { /* render is best-effort */ }
+            this.lastAgentRunOutcome = {
+                prompt,
+                taskId: null,
+                contextId: null,
+                tasksSucceeded: liveOutcome.tasksSucceeded,
+                tasksTotal: liveOutcome.tasksTotal,
+                failedTaskIds: [...liveOutcome.failedTaskIds],
+                unfinishedTaskIds: [...liveOutcome.unfinishedTaskIds],
+                qualityScore: liveOutcome.qualityScore,
+                qualityMissing: liveOutcome.qualityMissing,
+                qualityBlockers: liveOutcome.qualityBlockers,
+                hasOutput: this.api.hasAgentWorkspaceOutput(workspaceContext),
+                selfHealStatus: 'skipped',
+                selfHealTool: null,
+                plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
+                executorError: liveOutcome.executorError ? sanitizeUserFacingErrorText(liveOutcome.executorError) : safeDetail || null,
+                finishedAt: Date.now(),
+            };
             if (this.jsonOutput) {
                 process.exitCode = 1;
                 console.log(JSON.stringify({
@@ -2163,6 +2327,9 @@ export class ChatCommand {
                     metadata: { executionPath: 'v3-agent' },
                 }, null, 2));
             }
+            else if (!this.directPromptMode) {
+                this.printAgentRunSummary(this.lastAgentRunOutcome, false, 0);
+            }
             return true;
         }
     }
@@ -2350,6 +2517,38 @@ export class ChatCommand {
                 console.log(chalk.yellow('Conversation cleared.'));
                 continue;
             }
+            if (trimmed === '/status') {
+                this.showAgentRunStatus();
+                continue;
+            }
+            if (trimmed === '/retry') {
+                const followUp = this.buildRetryPrompt();
+                if (!followUp) {
+                    console.log(chalk.yellow('Nothing to retry — run an agent task first.'));
+                    continue;
+                }
+                if (!this.agentMode) {
+                    this.agentMode = true;
+                    this.syncInteractiveModeModel('agent');
+                    console.log(chalk.gray('Agent mode re-enabled for retry.'));
+                }
+                await this.runAgentTurn(followUp);
+                continue;
+            }
+            if (trimmed === '/continue') {
+                const followUp = this.buildContinuePrompt();
+                if (!followUp) {
+                    console.log(chalk.yellow('Nothing to continue — run an agent task first.'));
+                    continue;
+                }
+                if (!this.agentMode) {
+                    this.agentMode = true;
+                    this.syncInteractiveModeModel('agent');
+                    console.log(chalk.gray('Agent mode re-enabled for continuation.'));
+                }
+                await this.runAgentTurn(followUp);
+                continue;
+            }
             if (trimmed === '/save') {
                 this.saveSession();
                 console.log(chalk.green('Session saved.'));
@@ -2382,17 +2581,153 @@ export class ChatCommand {
     showHelp() {
         console.log('');
         console.log('Commands:');
-        console.log('  /help   Show this help');
-        console.log('  /exit   Exit chat');
-        console.log('  /agent  Toggle agent mode');
-        console.log('  /operator  Toggle BMAD operator mode');
-        console.log('  /context  Show current session and project memory');
-        console.log('  /memory  Show Vigthoria project brain status');
-        console.log('  /compact  Compact current session into memory summary');
-        console.log('  /clear  Clear conversation');
-        console.log('  /save   Save session');
+        console.log('  /help          Show this help');
+        console.log('  /exit          Exit chat');
+        console.log('  /agent         Toggle agent mode');
+        console.log('  /operator      Toggle BMAD operator mode');
+        console.log('  /context       Show current session and project memory');
+        console.log('  /memory        Show Vigthoria project brain status');
+        console.log('  /compact       Compact current session into memory summary');
+        console.log('  /clear         Clear conversation');
+        console.log('  /save          Save session');
         console.log('  /model <name>  Change model');
+        console.log('  /status        Show the last agent run outcome');
+        console.log('  /retry         Re-run the last failed agent task');
+        console.log('  /continue      Ask the agent to keep working on unfinished tasks');
+        console.log('');
+    }
+    /**
+     * Print a clear, opinionated end-of-run summary after every agent workflow.
+     *
+     * Goals:
+     *   - User can answer "Did it succeed?" in one glance.
+     *   - User can answer "What do I type next?" without reading 200 scrollback lines.
+     *   - Never leave the spinners (`⟳`, `–`) ambiguous when the prompt returns.
+     */
+    printAgentRunSummary(outcome, executorSucceeded, changedFileCount) {
+        const bar = chalk.gray('─'.repeat(63));
+        const ok = chalk.green('✓');
+        const warn = chalk.yellow('⚠');
+        const bad = chalk.red('✗');
+        const failedList = outcome.failedTaskIds.slice(0, 8);
+        const unfinishedList = outcome.unfinishedTaskIds.slice(0, 8);
+        const hasTaskInfo = outcome.tasksTotal > 0 || failedList.length > 0 || unfinishedList.length > 0;
+        console.log('');
+        console.log(bar);
+        if (executorSucceeded && outcome.selfHealStatus !== 'partial' && outcome.selfHealStatus !== 'failed' && failedList.length === 0) {
+            console.log(`${ok} ${chalk.bold('Agent run finished')}${changedFileCount ? chalk.gray(` — ${changedFileCount} file${changedFileCount === 1 ? '' : 's'} changed`) : ''}`);
+        }
+        else if (executorSucceeded) {
+            console.log(`${warn} ${chalk.bold('Agent run finished with warnings')}${changedFileCount ? chalk.gray(` — ${changedFileCount} file${changedFileCount === 1 ? '' : 's'} changed`) : ''}`);
+        }
+        else {
+            console.log(`${bad} ${chalk.bold('Agent run did not complete')}${changedFileCount ? chalk.gray(` — ${changedFileCount} file${changedFileCount === 1 ? '' : 's'} changed`) : ''}`);
+        }
+        if (hasTaskInfo) {
+            const succ = outcome.tasksTotal > 0 ? `${outcome.tasksSucceeded}/${outcome.tasksTotal}` : `${outcome.tasksSucceeded}`;
+            console.log(chalk.gray(`  Tasks completed: ${succ}`));
+            if (failedList.length > 0) {
+                const more = outcome.failedTaskIds.length > failedList.length ? chalk.gray(` (+${outcome.failedTaskIds.length - failedList.length} more)`) : '';
+                console.log(chalk.gray('  Failed:   ') + chalk.red(failedList.join(', ')) + more);
+            }
+            if (unfinishedList.length > 0) {
+                const more = outcome.unfinishedTaskIds.length > unfinishedList.length ? chalk.gray(` (+${outcome.unfinishedTaskIds.length - unfinishedList.length} more)`) : '';
+                console.log(chalk.gray('  Pending:  ') + chalk.yellow(unfinishedList.join(', ')) + more);
+            }
+        }
+        if (typeof outcome.qualityScore === 'number') {
+            const score = outcome.qualityScore.toFixed(1);
+            const colour = outcome.qualityScore >= 70 ? chalk.green : outcome.qualityScore >= 30 ? chalk.yellow : chalk.red;
+            console.log(chalk.gray('  Quality:  ') + colour(`${score}/100`));
+        }
+        if (outcome.qualityBlockers.length > 0) {
+            const list = outcome.qualityBlockers.slice(0, 3).join('; ');
+            const more = outcome.qualityBlockers.length > 3 ? chalk.gray(` (+${outcome.qualityBlockers.length - 3} more)`) : '';
+            console.log(chalk.gray('  Blockers: ') + chalk.yellow(list) + more);
+        }
+        if (outcome.qualityMissing.length > 0) {
+            const list = outcome.qualityMissing.slice(0, 5).join(', ');
+            const more = outcome.qualityMissing.length > 5 ? chalk.gray(` (+${outcome.qualityMissing.length - 5} more)`) : '';
+            console.log(chalk.gray('  Missing:  ') + chalk.yellow(list) + more);
+        }
+        if (outcome.plannerError) {
+            console.log(chalk.gray('  Planner:  ') + chalk.red(outcome.plannerError.slice(0, 140)));
+        }
+        if (outcome.executorError) {
+            console.log(chalk.gray('  Executor: ') + chalk.red(outcome.executorError.slice(0, 140)));
+        }
         console.log('');
+        console.log(chalk.gray('What you can do next:'));
+        if (failedList.length > 0 || unfinishedList.length > 0 || !executorSucceeded) {
+            console.log('  ' + chalk.cyan('/retry') + chalk.gray('     resume the failed/unfinished tasks only'));
+            console.log('  ' + chalk.cyan('/continue') + chalk.gray('  ask the agent to keep working from this state'));
+        }
+        else {
+            console.log('  ' + chalk.cyan('/continue') + chalk.gray('  add a follow-up instruction in this thread'));
+        }
+        if (changedFileCount > 0) {
+            console.log('  ' + chalk.cyan('vigthoria preview --diff') + chalk.gray('   inspect the file changes'));
+        }
+        console.log('  ' + chalk.cyan('/status') + chalk.gray('    re-print this summary later'));
+        console.log('  ' + chalk.cyan('/exit') + chalk.gray('      leave interactive chat'));
+        console.log(bar);
+        console.log('');
+    }
+    /**
+     * Build the prompt sent to the agent when the user types `/retry`.
+     * Resumes only the failed/unfinished tasks from the previous run.
+     */
+    buildRetryPrompt() {
+        const o = this.lastAgentRunOutcome;
+        if (!o || !o.prompt)
+            return null;
+        const remaining = [...new Set([...o.failedTaskIds, ...o.unfinishedTaskIds])];
+        const taskList = remaining.length > 0 ? remaining.join(', ') : '';
+        const blockerLine = o.qualityBlockers.length > 0
+            ? `\nKnown blockers to address: ${o.qualityBlockers.slice(0, 3).join('; ')}.`
+            : '';
+        const missingLine = o.qualityMissing.length > 0
+            ? `\nMissing pieces: ${o.qualityMissing.slice(0, 6).join(', ')}.`
+            : '';
+        if (taskList) {
+            return `Resume the previous agent run. Re-execute only these tasks and make them pass: ${taskList}.${blockerLine}${missingLine}\nOriginal request was: ${o.prompt}`;
+        }
+        return `Retry the previous request and make sure it finishes successfully.${blockerLine}${missingLine}\nOriginal request was: ${o.prompt}`;
+    }
+    /**
+     * Build the prompt sent to the agent when the user types `/continue`.
+     * Tells the agent to keep working from the current workspace state.
+     */
+    buildContinuePrompt() {
+        const o = this.lastAgentRunOutcome;
+        if (!o || !o.prompt)
+            return null;
+        const remaining = [...new Set([...o.failedTaskIds, ...o.unfinishedTaskIds])];
+        const taskList = remaining.length > 0 ? `\nRemaining tasks to finish: ${remaining.join(', ')}.` : '';
+        const blockerLine = o.qualityBlockers.length > 0
+            ? `\nKnown blockers to address: ${o.qualityBlockers.slice(0, 3).join('; ')}.`
+            : '';
+        const missingLine = o.qualityMissing.length > 0
+            ? `\nMissing pieces: ${o.qualityMissing.slice(0, 6).join(', ')}.`
+            : '';
+        return `Continue the previous agent run from the current workspace state without re-doing already-completed work.${taskList}${blockerLine}${missingLine}\nOriginal request was: ${o.prompt}`;
+    }
+    /**
+     * Re-print the last agent run summary, or guide the user when there isn't one.
+     */
+    showAgentRunStatus() {
+        if (!this.lastAgentRunOutcome) {
+            console.log(chalk.yellow('No agent run has finished in this session yet.'));
+            console.log(chalk.gray('Toggle agent mode with /agent and send a request to start one.'));
+            return;
+        }
+        const o = this.lastAgentRunOutcome;
+        const executorSucceeded = o.failedTaskIds.length === 0
+            && o.unfinishedTaskIds.length === 0
+            && !o.plannerError
+            && !o.executorError
+            && o.hasOutput;
+        this.printAgentRunSummary(o, executorSucceeded, 0);
     }
     showContext() {
         if (!this.currentSession) {

package/install.ps1

@@ -5,7 +5,7 @@
 $ErrorActionPreference = "Stop"
 
 # Configuration
-$CLI_VERSION = "1.9.1"
+$CLI_VERSION = "1.9.20"
 $INSTALL_DIR = "$env:USERPROFILE\.vigthoria"
 $NPM_PACKAGE = "vigthoria-cli"
 $GIT_PACKAGE_URL = "git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git"

package/install.sh

@@ -26,7 +26,7 @@ else
 fi
 
 # Configuration
-CLI_VERSION="1.9.1"
+CLI_VERSION="1.9.20"
 INSTALL_DIR="$HOME/.vigthoria"
 REPO_URL="https://market.vigthoria.io/vigthoria/vigthoria-cli"
 GIT_PACKAGE_URL="git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git"

package/package.json

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