vigthoria-cli 1.11.0 → 1.11.3

package/dist/commands/background.d.ts

@@ -15,5 +15,6 @@ export declare class BackgroundCommand {
     status(jobId: string, options?: BackgroundOptions): Promise<void>;
     apply(jobId: string, options?: BackgroundOptions): Promise<void>;
     cancel(jobId: string, options?: BackgroundOptions): Promise<void>;
+    private extractBackgroundOutcome;
 }
 export {};

package/dist/commands/background.js

@@ -82,8 +82,9 @@ export class BackgroundCommand {
         try {
             const job = await this.api.getV3BackgroundJob(jobId);
             spinner.stop();
+            const outcome = this.extractBackgroundOutcome(job);
             if (options.json) {
-                console.log(JSON.stringify(job, null, 2));
+                console.log(JSON.stringify({ ...job, outcomeTruth: outcome }, null, 2));
                 return;
             }
             console.log(chalk.bold(`\nBackground Job ${chalk.cyan(job.job_id)}\n`));
@@ -91,6 +92,12 @@ export class BackgroundCommand {
             console.log(`Files:     ${job.file_count || 0}`);
             console.log(`Updated:   ${job.updated_at || '-'}`);
             console.log(`Workspace: ${job.local_workspace_path || job.workspace_name || '-'}`);
+            if (outcome.tasksTotal > 0 || outcome.tasksCompleted > 0) {
+                console.log(`Tasks:     ${outcome.tasksCompleted}/${outcome.tasksTotal}${outcome.success === true ? chalk.green(' (complete)') : outcome.success === false ? chalk.red(' (incomplete)') : ''}`);
+            }
+            if (outcome.headline) {
+                console.log(chalk.gray(`Outcome:   ${outcome.headline}`));
+            }
             if (job.error)
                 console.log(chalk.red(`Error:     ${job.error}`));
             console.log(chalk.gray(`\n${String(job.request || '').slice(0, 500)}`));
@@ -157,4 +164,51 @@ export class BackgroundCommand {
             this.logger.error(error?.message || String(error));
         }
     }
+    extractBackgroundOutcome(job) {
+        const result = (job?.result && typeof job.result === 'object') ? job.result : {};
+        const events = Array.isArray(job?.events) ? job.events : [];
+        let tasksCompleted = Number(result.tasks_completed ?? result.tasksCompleted ?? 0);
+        let tasksTotal = Number(result.tasks_total ?? result.tasksTotal ?? 0);
+        let success = typeof result.success === 'boolean' ? result.success : null;
+        for (const event of events) {
+            if (!event || typeof event !== 'object')
+                continue;
+            if (event.type === 'result' || event.event === 'result') {
+                const payload = event.data || event.payload || event;
+                if (payload && typeof payload === 'object') {
+                    if (payload.tasks_completed != null)
+                        tasksCompleted = Number(payload.tasks_completed);
+                    if (payload.tasksCompleted != null)
+                        tasksCompleted = Number(payload.tasksCompleted);
+                    if (payload.tasks_total != null)
+                        tasksTotal = Number(payload.tasks_total);
+                    if (payload.tasksTotal != null)
+                        tasksTotal = Number(payload.tasksTotal);
+                    if (typeof payload.success === 'boolean')
+                        success = payload.success;
+                }
+            }
+        }
+        if (success == null && tasksTotal > 0) {
+            success = tasksCompleted >= tasksTotal;
+        }
+        if (success == null && job?.status === 'completed') {
+            success = true;
+        }
+        if (success == null && job?.status === 'failed') {
+            success = false;
+        }
+        let headline = '';
+        if (tasksTotal > 0) {
+            headline = success === true
+                ? `All ${tasksTotal} task(s) completed`
+                : success === false
+                    ? `${tasksCompleted}/${tasksTotal} task(s) completed`
+                    : `${tasksCompleted}/${tasksTotal} task(s) reported`;
+        }
+        else if (typeof result.message === 'string' && result.message.trim()) {
+            headline = result.message.trim();
+        }
+        return { tasksCompleted, tasksTotal, success, headline };
+    }
 }

package/dist/commands/chat.d.ts

@@ -17,6 +17,8 @@ interface ChatOptions {
     json?: boolean;
     bridge?: string;
     grant?: boolean;
+    retry?: boolean;
+    continue?: boolean;
 }
 export declare class ChatCommand {
     private config;

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 { evaluateExecutorSuccess, handleTaskEvent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
+import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, 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) {
@@ -477,6 +477,10 @@ export class ChatCommand {
      */
     isOperatorDirectAnswerable(prompt) {
         const trimmed = prompt.trim();
+        // Infrastructure status pings are never repo-grounded analysis.
+        if (/^(status(\s+check)?|health(\s+check)?|ping)$/i.test(trimmed)) {
+            return true;
+        }
         // ── Exclusion guard: any prompt that references code artefacts,
         // file paths, or analysis verbs MUST go through a tool-backed path
         // (BMAD or agent loop), never the toolless direct-answer shortcut.
@@ -711,6 +715,9 @@ export class ChatCommand {
         }
     }
     writeV3StreamText(spinner, text) {
+        if (this.jsonOutput) {
+            return;
+        }
         const safeText = this.sanitizeV3VisibleStreamText(this.sanitizeServerPath(text));
         if (!safeText) {
             return;
@@ -1137,14 +1144,14 @@ export class ChatCommand {
             }
             console.log(chalk.green(`Using workspace: ${this.currentProjectPath}`));
         }
-        if (this.jsonOutput && !options.prompt) {
-            throw new Error('--json is only supported together with --prompt.');
+        if (this.jsonOutput && !options.prompt && !options.retry && !options.continue) {
+            throw new Error('--json is only supported together with --prompt, --retry, or --continue.');
         }
         this.ensureProjectWorkspace();
         this.directPromptMode = Boolean(options.prompt);
         this.directToolContinuationCount = 0;
         this.tools = new AgenticTools(this.logger, this.currentProjectPath, async (action) => this.requestPermission(action), this.autoApprove);
-        this.initializeSession(options.resume === true);
+        this.initializeSession(options.resume === true || options.retry === true || options.continue === true);
         // ── Commando Bridge: connect if --bridge was specified ──────────
         if (options.bridge) {
             const bridgeClient = new BridgeClient({
@@ -1169,6 +1176,18 @@ export class ChatCommand {
             this.logger.error(this.operatorAccessMessage());
             return;
         }
+        if (options.retry || options.continue) {
+            if (!this.agentMode) {
+                throw new Error('--retry and --continue require agent mode.');
+            }
+            const followUp = options.retry ? this.buildRetryPrompt() : this.buildContinuePrompt();
+            if (!followUp) {
+                throw new Error('No previous agent run to retry or continue. Run an agent prompt first with the same --project, or use --resume.');
+            }
+            this.directPromptMode = true;
+            await this.runAgentTurn(followUp);
+            return;
+        }
         if (options.prompt) {
             const bridgePromptTimeoutMs = (() => {
                 const rawValue = process.env.VIGTHORIA_BRIDGE_PROMPT_TIMEOUT_MS || process.env.V3_BRIDGE_PROMPT_TIMEOUT_MS;
@@ -1404,6 +1423,9 @@ export class ChatCommand {
                 this.agentMode = this.currentSession.agentMode || this.agentMode;
                 this.operatorMode = this.currentSession.operatorMode || this.operatorMode;
                 this.currentModel = this.currentSession.model || this.currentModel;
+                if (this.currentSession.lastAgentRunOutcome) {
+                    this.lastAgentRunOutcome = this.currentSession.lastAgentRunOutcome;
+                }
                 return;
             }
         }
@@ -2368,20 +2390,11 @@ export class ChatCommand {
         }).start();
         // Live run telemetry, used both for the final summary block and for /retry, /continue.
         const liveOutcome = {
-            tasksSucceeded: 0,
-            tasksTotal: 0,
-            failedTaskIds: new Set(),
+            ...createLiveOutcome(),
             unfinishedTaskIds: new Set(),
             qualityScore: null,
             qualityMissing: [],
             qualityBlockers: [],
-            plannerError: null,
-            executorError: null,
-            executorFailed: false,
-            analysisToolsUsed: 0,
-            changedFileCount: 0,
-            requiresWorkspaceChanges: false,
-            workspaceHasOutput: false,
         };
         const parsePlannerSummary = (raw) => {
             if (!raw || typeof raw !== 'string')
@@ -2498,7 +2511,7 @@ export class ChatCommand {
                     else if (event.type === 'executor_complete') {
                         const summary = event.summary || {};
                         handleTaskEvent(summary, liveOutcome);
-                        if (summary.status === 'failed') {
+                        if (summary.status === 'failed' || summary.status === 'stalled_error') {
                             const err = typeof summary.error === 'string' ? summary.error.trim() : '';
                             if (err && !liveOutcome.executorError)
                                 liveOutcome.executorError = err;
@@ -2510,6 +2523,10 @@ export class ChatCommand {
                             noteAnalysisToolUse(toolName, liveOutcome);
                     }
                     else if (event.type === 'complete') {
+                        const tt = Number(event.tasks_total);
+                        if (Number.isFinite(tt) && tt > 0) {
+                            liveOutcome.tasksTotal = tt;
+                        }
                         if (Number(event.discovery_tools_used) > 0) {
                             liveOutcome.analysisToolsUsed = Math.max(liveOutcome.analysisToolsUsed, Number(event.discovery_tools_used));
                         }
@@ -2589,20 +2606,7 @@ export class ChatCommand {
             if (!this.jsonOutput && previewGate?.required && previewGate?.passed !== true && workspaceHasOutput) {
                 console.log(chalk.yellow(`Template Service preview gate did not fully validate this output, but generated workspace files were preserved${previewGate?.error ? `: ${previewGate.error}` : '.'}`));
             }
-            if (this.jsonOutput) {
-                console.log(JSON.stringify({
-                    success,
-                    mode: 'agent',
-                    model: routingPolicy.selectedModel,
-                    routingPolicy,
-                    taskId: response.taskId || null,
-                    contextId: response.contextId || null,
-                    partial: response.partial === true,
-                    content: response.content || 'V3 agent workflow completed.',
-                    metadata: response.metadata || {},
-                }, null, 2));
-            }
-            else if (this.v3StreamingStarted) {
+            if (this.v3StreamingStarted) {
                 // Content was already streamed to stdout in real-time; skip duplicate print.
                 if (!this.jsonOutput) {
                     console.log(chalk.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'}`));
@@ -2720,6 +2724,9 @@ export class ChatCommand {
             }
             taskDisplay.finalize();
             // ────────────────────────────────────────────────────────────────
+            if (!executorSucceeded) {
+                process.exitCode = 1;
+            }
             this.lastAgentRunOutcome = {
                 prompt,
                 taskId: response.taskId || null,
@@ -2747,7 +2754,35 @@ export class ChatCommand {
             if (!this.jsonOutput && !this.directPromptMode) {
                 this.printAgentRunSummary(this.lastAgentRunOutcome, runEvaluation, changedFileCount);
             }
-            this.messages.push({ role: 'assistant', content: response.content || 'V3 agent workflow completed.' });
+            if (this.jsonOutput) {
+                if (!executorSucceeded) {
+                    process.exitCode = 1;
+                }
+                console.log(JSON.stringify({
+                    success: executorSucceeded,
+                    mode: 'agent',
+                    model: routingPolicy.selectedModel,
+                    routingPolicy,
+                    taskId: response.taskId || null,
+                    contextId: response.contextId || null,
+                    partial: response.partial === true || (!executorSucceeded && liveOutcome.tasksSucceeded > 0),
+                    content: response.content || runEvaluation.statusHeadline,
+                    statusHeadline: runEvaluation.statusHeadline,
+                    tasksSucceeded: liveOutcome.tasksSucceeded,
+                    tasksTotal: liveOutcome.tasksTotal,
+                    metadata: {
+                        ...(response.metadata || {}),
+                        outcomeTruth: {
+                            executorSucceeded,
+                            uiTheme: runEvaluation.uiTheme,
+                            tasksSucceeded: liveOutcome.tasksSucceeded,
+                            tasksTotal: liveOutcome.tasksTotal,
+                        },
+                        previewGate,
+                    },
+                }, null, 2));
+            }
+            this.messages.push({ role: 'assistant', content: response.content || runEvaluation.statusHeadline });
             watcher?.stop();
             return true;
         }
@@ -2776,6 +2811,10 @@ 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 });
+            liveOutcome.streamAborted = true;
+            if (!liveOutcome.executorError) {
+                liveOutcome.executorError = safeDetail || 'Connection aborted';
+            }
             // Resolve any half-rendered TaskDisplay spinners before the prompt
             // comes back, otherwise the user sees `⟳ Execute tasks` next to `>`.
             try {
@@ -2807,30 +2846,32 @@ export class ChatCommand {
                 workspaceSyncIssue: null,
                 finishedAt: Date.now(),
             };
+            if (!this.jsonOutput) {
+                process.exitCode = 1;
+            }
             if (this.jsonOutput) {
                 process.exitCode = 1;
                 console.log(JSON.stringify({
                     success: false,
                     mode: 'agent',
                     model: routingPolicy.selectedModel,
-                    partial: false,
+                    partial: liveOutcome.tasksSucceeded > 0 && liveOutcome.tasksTotal > 0,
                     content: '',
                     error: errorMessage,
+                    statusHeadline: evaluateExecutorSuccess(liveOutcome).statusHeadline,
+                    tasksSucceeded: liveOutcome.tasksSucceeded,
+                    tasksTotal: liveOutcome.tasksTotal,
                     metadata: { executionPath: 'v3-agent' },
                 }, null, 2));
             }
             else if (!this.directPromptMode) {
                 const failedEval = evaluateExecutorSuccess({
+                    ...liveOutcome,
                     executorFailed: true,
-                    plannerError: liveOutcome.plannerError,
                     executorError: liveOutcome.executorError || safeDetail,
-                    tasksTotal: liveOutcome.tasksTotal,
-                    tasksSucceeded: liveOutcome.tasksSucceeded,
                     changedFileCount: 0,
                     requiresWorkspaceChanges: this.taskRequiresWorkspaceChanges(prompt),
                     workspaceHasOutput: this.api.hasAgentWorkspaceOutput(workspaceContext),
-                    failedTaskIds: liveOutcome.failedTaskIds,
-                    analysisToolsUsed: liveOutcome.analysisToolsUsed,
                 });
                 this.printAgentRunSummary(this.lastAgentRunOutcome, failedEval, 0);
             }
@@ -3312,16 +3353,15 @@ export class ChatCommand {
         }
         const o = this.lastAgentRunOutcome;
         const statusEval = evaluateExecutorSuccess({
+            ...createLiveOutcome(),
             executorFailed: o.failedTaskIds.length > 0,
             plannerError: o.plannerError,
             executorError: o.executorError,
             tasksTotal: o.tasksTotal,
             tasksSucceeded: o.tasksSucceeded,
-            changedFileCount: 0,
             requiresWorkspaceChanges: this.taskRequiresWorkspaceChanges(o.prompt),
             workspaceHasOutput: o.hasOutput,
             failedTaskIds: new Set(o.failedTaskIds),
-            analysisToolsUsed: 0,
         });
         this.printAgentRunSummary(o, statusEval, 0);
     }
@@ -4132,6 +4172,7 @@ export class ChatCommand {
         this.currentSession.agentMode = this.agentMode;
         this.currentSession.operatorMode = this.operatorMode;
         this.currentSession.messages = [...this.messages];
+        this.currentSession.lastAgentRunOutcome = this.lastAgentRunOutcome;
         this.currentSession = this.sessionManager.compactInMemory(this.currentSession);
         this.messages = [...this.currentSession.messages];
         this.sessionManager.save(this.currentSession);

package/dist/index.js

@@ -614,6 +614,8 @@ export async function main(args) {
         .option('--prompt <text>', 'Run a single agent prompt directly and exit')
         .option('-w, --workflow <selector>', 'Run the prompt through a named or explicit VigFlow workflow target')
         .option('--json', 'Emit machine-readable JSON output for direct prompt runs', false)
+        .option('--retry', 'Retry failed tasks from the last agent run in this workspace session', false)
+        .option('--continue', 'Continue unfinished tasks from the last agent run in this workspace session', false)
         .option('--auto-approve', 'Auto-approve all actions (dangerous!)', false)
         .option('--bridge <url>', 'Connect to Vigthoria Commando Bridge for remote admin observability')
         .action(async (options) => {
@@ -630,6 +632,8 @@ export async function main(args) {
             autoApprove: options.autoApprove,
             prompt: options.prompt,
             bridge: options.bridge,
+            retry: options.retry,
+            continue: options.continue,
         });
     });
     program

package/dist/utils/agentRunOutcome.d.ts

@@ -12,7 +12,9 @@ export interface LiveOutcome {
     requiresWorkspaceChanges: boolean;
     workspaceHasOutput: boolean;
     failedTaskIds: Set<string>;
+    completedTaskIds: Set<string>;
     analysisToolsUsed: number;
+    streamAborted?: boolean;
 }
 export interface TaskSummaryEvent {
     status?: string;

package/dist/utils/agentRunOutcome.js

@@ -13,24 +13,36 @@ export function createLiveOutcome() {
         requiresWorkspaceChanges: false,
         workspaceHasOutput: false,
         failedTaskIds: new Set(),
+        completedTaskIds: new Set(),
         analysisToolsUsed: 0,
+        streamAborted: false,
     };
 }
 /** Process executor_complete / task summary events from the V3 SSE stream. */
 export function handleTaskEvent(summary, liveOutcome) {
     const tid = summary.task_id || summary.id;
     const status = String(summary.status || '').toLowerCase();
+    if (!liveOutcome.completedTaskIds) {
+        liveOutcome.completedTaskIds = new Set();
+    }
     if (status === 'completed' || status === 'success') {
         if (tid) {
-            liveOutcome.failedTaskIds.delete(String(tid));
+            const id = String(tid);
+            if (liveOutcome.completedTaskIds.has(id))
+                return;
+            liveOutcome.completedTaskIds.add(id);
+            liveOutcome.failedTaskIds.delete(id);
         }
         liveOutcome.tasksSucceeded += 1;
     }
-    else if (status === 'failed' || status === 'blocked') {
+    else if (status === 'failed' || status === 'blocked' || status === 'stalled_error') {
         if (tid) {
             liveOutcome.failedTaskIds.add(String(tid));
         }
         liveOutcome.executorFailed = true;
+        if (status === 'stalled_error') {
+            liveOutcome.streamAborted = true;
+        }
     }
 }
 const READ_DISCOVERY_TOOLS = new Set([
@@ -57,7 +69,18 @@ export function noteAnalysisToolUse(toolName, liveOutcome) {
 export function evaluateExecutorSuccess(liveOutcome) {
     const hasFatalError = liveOutcome.executorFailed
         || Boolean(liveOutcome.plannerError)
-        || Boolean(liveOutcome.executorError);
+        || Boolean(liveOutcome.executorError)
+        || Boolean(liveOutcome.streamAborted);
+    if (liveOutcome.streamAborted && liveOutcome.tasksTotal > 0) {
+        const partial = liveOutcome.tasksSucceeded > 0;
+        return {
+            executorSucceeded: false,
+            statusHeadline: partial
+                ? `⚠ ${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal} tasks completed — connection aborted`
+                : `✕ Connection aborted — 0/${liveOutcome.tasksTotal} tasks completed`,
+            uiTheme: 'warning',
+        };
+    }
     if (hasFatalError && liveOutcome.tasksTotal === 0) {
         return {
             executorSucceeded: false,

package/dist/utils/api.js

@@ -1648,6 +1648,8 @@ export class APIClient {
         const serverWorkspacePath = this.resolveServerBindableWorkspacePath(resolvedContext);
         const localWorkspaceName = this.getDisplayWorkspaceName(targetPath);
         const localWorkspaceRef = localWorkspaceName ? `vigthoria://local-workspace/${localWorkspaceName}` : null;
+        const rawBrain = resolvedContext.vigthoriaBrain || resolvedContext.vigthoria_brain || null;
+        const dedupedBrain = rawBrain ? this.dedupeBrainPayload(rawBrain) : null;
         return JSON.stringify({
             workspace: this.buildPublicWorkspaceDescriptor(resolvedContext.workspace, {
                 localWorkspacePath: targetPath,
@@ -1681,8 +1683,8 @@ export class APIClient {
             contextId: resolvedContext.contextId,
             traceId: resolvedContext.traceId,
             requestStartedAt: resolvedContext.requestStartedAt,
-            vigthoriaBrain: resolvedContext.vigthoriaBrain || null,
-            vigthoria_brain: resolvedContext.vigthoriaBrain || null,
+            vigthoriaBrain: dedupedBrain,
+            vigthoria_brain: dedupedBrain,
         });
     }
     extractEmergencyAppName(message = '', fallback = 'Signal Desk') {

package/dist/utils/session.d.ts

@@ -46,6 +46,7 @@ export interface Session {
     updatedAt: string;
     agentMode: boolean;
     operatorMode?: boolean;
+    lastAgentRunOutcome?: Record<string, unknown> | null;
 }
 export declare class SessionManager {
     private sessionsDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.11.0",
+  "version": "1.11.3",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -36,7 +36,8 @@
     "start": "node dist/index.js",
     "dev": "ts-node src/index.ts",
     "test": "npm run test:cli",
-    "test:cli": "npm run build && npm run precheck:services && node scripts/test-cli-suite.js",
+    "test:agent:outcome": "npm run build && node scripts/test-agent-run-outcome.js",
+    "test:cli": "npm run build && npm run precheck:services && node scripts/test-cli-suite.js && npm run test:agent:outcome",
     "test:regression": "npm run build && node scripts/test-regression-1.6.22.js",
     "test:agent:smoke": "npm run build && node scripts/test-agent-smoke.js",
     "test:agent:routing": "npm run build && node scripts/test-agent-routing-policy.js",

package/scripts/release/validate-no-go-gates.sh

@@ -76,7 +76,7 @@ $CLI hyper-loop status >/tmp/vig-hyperloop.txt
 $CLI devtools connect >/tmp/vig-devtools.txt
 
 echo "[6.11] operator flow"
-$CLI operator --prompt "status check" --json >/tmp/vig-operator.json
+$CLI operator --prompt "reply with exactly: OK" --json >/tmp/vig-operator.json
 python3 - << 'PY'
 import json
 j=json.load(open('/tmp/vig-operator.json'))
@@ -131,4 +131,7 @@ assert fb.get('reason') == 'governance-blocked-model', j
 print('[pass] governance fallback metadata')
 PY
 
+echo "[outcome-truth] agent run outcome regression"
+npm run test:agent:outcome
+
 echo "ALL NO-GO GATES PASSED"