vigthoria-cli 1.10.55 → 1.11.2

package/dist/commands/chat.js

@@ -13,6 +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';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
@@ -353,7 +354,12 @@ export class ChatCommand {
      * question — these should use analysis_only workflow, not full_autonomy.
      */
     isAnalysisLookupPrompt(prompt) {
-        return /^(what|which|where|how many|who|find|list|show|check|inspect|analyze|analyse|audit|explain|describe|summarize|summarise|review|overview|count|read|look at|tell me|locate|search for|does .* exist)/i.test(prompt.trim());
+        const trimmed = prompt.trim();
+        if (/^(what|which|where|how many|who|find|list|show|check|inspect|analyze|analyse|audit|explain|describe|summarize|summarise|review|overview|count|read|look at|tell me|locate|search for|does .* exist)/i.test(trimmed)) {
+            return true;
+        }
+        // Mid-conversation accountability / lookup questions (Gideon regression)
+        return /\b(where\s+(?:is|are)|what\s+(?:is|are|have|did|was|were)|how\s+(?:do|does|is|are)|what\s+(?:have\s+)?you\s+(?:done|changed|built)|what\s+(?:is|was)\s+(?:your|the)\s+answer)\b/i.test(trimmed);
     }
     extractExplicitLocalPath(prompt) {
         // Try to extract Windows paths (C:\ D:\ etc.)
@@ -2362,16 +2368,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,
         };
         const parsePlannerSummary = (raw) => {
             if (!raw || typeof raw !== 'string')
@@ -2487,20 +2488,27 @@ export class ChatCommand {
                     }
                     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;
+                        handleTaskEvent(summary, liveOutcome);
+                        if (summary.status === 'failed' || summary.status === 'stalled_error') {
                             const err = typeof summary.error === 'string' ? summary.error.trim() : '';
                             if (err && !liveOutcome.executorError)
                                 liveOutcome.executorError = err;
                         }
-                        else if (summary.status === 'completed' || summary.status === 'success') {
-                            if (tid)
-                                liveOutcome.failedTaskIds.delete(String(tid));
-                            liveOutcome.tasksSucceeded += 1;
+                    }
+                    else if (event.type === 'tool_call' || event.type === 'tool_result') {
+                        const toolName = String(event.name || event.tool || '').trim();
+                        if (toolName)
+                            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));
                         }
+                        taskDisplay.complete(1);
                     }
                     else if (event.type === 'executor_error') {
                         const msg = typeof event.error === 'string' ? event.error : '';
@@ -2520,9 +2528,6 @@ export class ChatCommand {
                             parsePlannerSummary(msg);
                         }
                     }
-                    else if (event.type === 'complete') {
-                        taskDisplay.complete(1);
-                    }
                     if (spinner)
                         this.updateV3AgentSpinner(spinner, event);
                 },
@@ -2539,6 +2544,9 @@ export class ChatCommand {
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
             const changedFileCount = response.changedFiles ? Object.keys(response.changedFiles).length : 0;
             const requiresWorkspaceChanges = this.taskRequiresWorkspaceChanges(prompt);
+            liveOutcome.changedFileCount = changedFileCount;
+            liveOutcome.requiresWorkspaceChanges = requiresWorkspaceChanges;
+            liveOutcome.workspaceHasOutput = workspaceHasOutput;
             const success = previewGate?.required === true
                 ? (previewGate?.passed === true || workspaceHasOutput)
                 : true;
@@ -2576,20 +2584,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'}`));
@@ -2634,10 +2629,8 @@ export class ChatCommand {
             // 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
-                && (requiresWorkspaceChanges ? (workspaceHasOutput && changedFileCount > 0) : true);
+            const runEvaluation = evaluateExecutorSuccess(liveOutcome);
+            const executorSucceeded = runEvaluation.executorSucceeded;
             if (!executorSucceeded && requiresWorkspaceChanges && changedFileCount === 0 && !liveOutcome.executorError) {
                 const clientToolErrors = this.api.getClientToolErrors();
                 const transportErrors = this.api.getLastChatTransportErrors();
@@ -2709,6 +2702,9 @@ export class ChatCommand {
             }
             taskDisplay.finalize();
             // ────────────────────────────────────────────────────────────────
+            if (!executorSucceeded) {
+                process.exitCode = 1;
+            }
             this.lastAgentRunOutcome = {
                 prompt,
                 taskId: response.taskId || null,
@@ -2734,9 +2730,37 @@ export class ChatCommand {
                 finishedAt: Date.now(),
             };
             if (!this.jsonOutput && !this.directPromptMode) {
-                this.printAgentRunSummary(this.lastAgentRunOutcome, executorSucceeded, changedFileCount);
+                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;
         }
@@ -2765,6 +2789,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 {
@@ -2796,20 +2824,34 @@ 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) {
-                this.printAgentRunSummary(this.lastAgentRunOutcome, false, 0);
+                const failedEval = evaluateExecutorSuccess({
+                    ...liveOutcome,
+                    executorFailed: true,
+                    executorError: liveOutcome.executorError || safeDetail,
+                    changedFileCount: 0,
+                    requiresWorkspaceChanges: this.taskRequiresWorkspaceChanges(prompt),
+                    workspaceHasOutput: this.api.hasAgentWorkspaceOutput(workspaceContext),
+                });
+                this.printAgentRunSummary(this.lastAgentRunOutcome, failedEval, 0);
             }
             return true;
         }
@@ -3106,7 +3148,8 @@ export class ChatCommand {
      *   - 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) {
+    printAgentRunSummary(outcome, evaluation, changedFileCount) {
+        const executorSucceeded = evaluation.executorSucceeded;
         const bar = chalk.gray('─'.repeat(63));
         const ok = chalk.green('✓');
         const warn = chalk.yellow('⚠');
@@ -3116,15 +3159,9 @@ export class ChatCommand {
         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`) : ''}`);
-        }
+        const headlineIcon = evaluation.uiTheme === 'success' ? ok : evaluation.uiTheme === 'warning' ? warn : bad;
+        const headlineText = evaluation.statusHeadline.replace(/^[✓⚠✕]\s*/, '');
+        console.log(`${headlineIcon} ${chalk.bold(headlineText)}${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}`));
@@ -3293,12 +3330,18 @@ export class ChatCommand {
             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);
+        const statusEval = evaluateExecutorSuccess({
+            ...createLiveOutcome(),
+            executorFailed: o.failedTaskIds.length > 0,
+            plannerError: o.plannerError,
+            executorError: o.executorError,
+            tasksTotal: o.tasksTotal,
+            tasksSucceeded: o.tasksSucceeded,
+            requiresWorkspaceChanges: this.taskRequiresWorkspaceChanges(o.prompt),
+            workspaceHasOutput: o.hasOutput,
+            failedTaskIds: new Set(o.failedTaskIds),
+        });
+        this.printAgentRunSummary(o, statusEval, 0);
     }
     showContext() {
         if (!this.currentSession) {

package/dist/utils/agentRunOutcome.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Task-and-quality-validated success evaluation for V3 agent runs.
+ * Decouples CLI verdict from raw file-change counts (1.11.0+).
+ */
+export interface LiveOutcome {
+    executorFailed: boolean;
+    plannerError: string | null;
+    executorError: string | null;
+    tasksTotal: number;
+    tasksSucceeded: number;
+    changedFileCount: number;
+    requiresWorkspaceChanges: boolean;
+    workspaceHasOutput: boolean;
+    failedTaskIds: Set<string>;
+    completedTaskIds: Set<string>;
+    analysisToolsUsed: number;
+    streamAborted?: boolean;
+}
+export interface TaskSummaryEvent {
+    status?: string;
+    task_id?: string;
+    id?: string;
+}
+export interface RunEvaluation {
+    executorSucceeded: boolean;
+    statusHeadline: string;
+    uiTheme: 'success' | 'warning' | 'error';
+}
+export declare function createLiveOutcome(): LiveOutcome;
+/** 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. */
+export declare function noteAnalysisToolUse(toolName: string, liveOutcome: LiveOutcome): void;
+/**
+ * Compute the real CLI success verdict.
+ * When tasks were planned, ALL must succeed — file changes alone never imply victory.
+ */
+export declare function evaluateExecutorSuccess(liveOutcome: LiveOutcome): RunEvaluation;

package/dist/utils/agentRunOutcome.js

@@ -0,0 +1,146 @@
+/**
+ * Task-and-quality-validated success evaluation for V3 agent runs.
+ * Decouples CLI verdict from raw file-change counts (1.11.0+).
+ */
+export function createLiveOutcome() {
+    return {
+        executorFailed: false,
+        plannerError: null,
+        executorError: null,
+        tasksTotal: 0,
+        tasksSucceeded: 0,
+        changedFileCount: 0,
+        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) {
+            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' || 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([
+    'read_file',
+    'grep',
+    'list_directory',
+    'glob',
+    'search_project',
+    'list_dir',
+    'dir',
+    'read',
+]);
+/** Track read/discovery tool usage for analysis-turn accountability. */
+export function noteAnalysisToolUse(toolName, liveOutcome) {
+    const normalized = String(toolName || '').trim().toLowerCase();
+    if (READ_DISCOVERY_TOOLS.has(normalized)) {
+        liveOutcome.analysisToolsUsed += 1;
+    }
+}
+/**
+ * Compute the real CLI success verdict.
+ * When tasks were planned, ALL must succeed — file changes alone never imply victory.
+ */
+export function evaluateExecutorSuccess(liveOutcome) {
+    const hasFatalError = liveOutcome.executorFailed
+        || Boolean(liveOutcome.plannerError)
+        || 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,
+            statusHeadline: '✕ Execution Error',
+            uiTheme: 'error',
+        };
+    }
+    if (liveOutcome.tasksTotal > 0) {
+        const allTasksPassed = liveOutcome.tasksSucceeded === liveOutcome.tasksTotal;
+        const partialTasksPassed = liveOutcome.tasksSucceeded > 0;
+        const failedCount = liveOutcome.failedTaskIds.size;
+        if (allTasksPassed && !hasFatalError) {
+            return {
+                executorSucceeded: true,
+                statusHeadline: `✓ Agent run finished (${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal} tasks completed)`,
+                uiTheme: 'success',
+            };
+        }
+        if (partialTasksPassed) {
+            return {
+                executorSucceeded: false,
+                statusHeadline: `⚠ Warning: Partial Run (${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal} tasks completed${failedCount ? `, ${failedCount} failed` : ''})`,
+                uiTheme: 'warning',
+            };
+        }
+        return {
+            executorSucceeded: false,
+            statusHeadline: `✕ Failed: 0/${liveOutcome.tasksTotal} tasks completed${liveOutcome.changedFileCount > 0 ? ' (stub writes or stalls detected)' : ''}`,
+            uiTheme: 'error',
+        };
+    }
+    // Analysis / verification turns with no planned task graph
+    if (!liveOutcome.requiresWorkspaceChanges) {
+        const analysisOk = liveOutcome.analysisToolsUsed > 0 || liveOutcome.workspaceHasOutput;
+        if (!analysisOk && hasFatalError) {
+            return {
+                executorSucceeded: false,
+                statusHeadline: '✕ Analysis failed — no workspace evidence gathered',
+                uiTheme: 'error',
+            };
+        }
+        if (!analysisOk) {
+            return {
+                executorSucceeded: false,
+                statusHeadline: '⚠ Warning: No read tools confirmed — answer may be incomplete',
+                uiTheme: 'warning',
+            };
+        }
+        return {
+            executorSucceeded: true,
+            statusHeadline: '✓ Analysis completed',
+            uiTheme: 'success',
+        };
+    }
+    const legacySuccess = liveOutcome.workspaceHasOutput && liveOutcome.changedFileCount > 0;
+    return {
+        executorSucceeded: legacySuccess && !hasFatalError,
+        statusHeadline: legacySuccess && !hasFatalError
+            ? '✓ Agent run finished'
+            : '✕ No validated workspace output',
+        uiTheme: legacySuccess && !hasFatalError ? 'success' : 'error',
+    };
+}

package/dist/utils/api.d.ts

@@ -334,6 +334,8 @@ export declare class APIClient {
      *   5. Drop readmeExcerpt
      */
     private compactV3Context;
+    /** Remove duplicate functionIndex entries that poison model context after compaction. */
+    private dedupeBrainPayload;
     buildMinimalV3AgentContext(context?: Record<string, any>): string;
     private extractEmergencyAppName;
     private materializeEmergencySaaSWorkspace;

package/dist/utils/api.js

@@ -1513,6 +1513,12 @@ export class APIClient {
      */
     compactV3Context(payload) {
         const LIMIT = APIClient.V3_CONTEXT_CHAR_LIMIT;
+        if (payload.vigthoriaBrain) {
+            payload.vigthoriaBrain = this.dedupeBrainPayload(payload.vigthoriaBrain);
+        }
+        if (payload.vigthoria_brain) {
+            payload.vigthoria_brain = payload.vigthoriaBrain || this.dedupeBrainPayload(payload.vigthoria_brain);
+        }
         let json = JSON.stringify(payload);
         if (json.length <= LIMIT)
             return json;
@@ -1586,6 +1592,51 @@ export class APIClient {
         }
         return json;
     }
+    /** Remove duplicate functionIndex entries that poison model context after compaction. */
+    dedupeBrainPayload(brain) {
+        if (!brain || typeof brain !== 'object') {
+            return brain;
+        }
+        const copy = { ...brain };
+        const dedupeIndexEntries = (entries) => {
+            const seen = new Set();
+            const unique = [];
+            for (const entry of entries) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const file = String(entry.file || '')
+                    .replace(/\\/g, '/')
+                    .replace(/^home\/user\//i, '')
+                    .toLowerCase();
+                const name = String(entry.name || '');
+                const line = String(entry.line ?? '');
+                const key = `${name}::${file}::${line}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                unique.push(entry);
+            }
+            return unique;
+        };
+        if (copy.functionIndex && typeof copy.functionIndex === 'object') {
+            const deduped = {};
+            for (const [symbol, entries] of Object.entries(copy.functionIndex)) {
+                deduped[symbol] = Array.isArray(entries) ? dedupeIndexEntries(entries) : [];
+            }
+            copy.functionIndex = deduped;
+        }
+        if (copy.files && typeof copy.files === 'object') {
+            const normalized = {};
+            for (const [filePath, meta] of Object.entries(copy.files)) {
+                const norm = String(filePath).replace(/\\/g, '/').replace(/^home\/user\//i, '');
+                if (!(norm in normalized)) {
+                    normalized[norm] = meta;
+                }
+            }
+            copy.files = normalized;
+        }
+        return copy;
+    }
     buildMinimalV3AgentContext(context = {}) {
         const resolvedContext = this.ensureExecutionContext(context);
         const targetPath = this.resolveAgentTargetPath(resolvedContext)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.10.55",
+  "version": "1.11.2",
   "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

@@ -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"