vigthoria-cli 1.11.2 → 1.11.4

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;
@@ -147,6 +149,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

@@ -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;
             }
         }
@@ -1918,6 +1940,42 @@ 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,
+            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.');
@@ -1953,14 +2011,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 {
@@ -2056,15 +2126,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));
                     }
@@ -2109,6 +2190,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({
@@ -2118,8 +2206,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));
         }
@@ -4150,6 +4243,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/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.2",
+  "version": "1.11.4",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.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'))