vigthoria-cli 1.11.28 → 1.11.31

package/dist/commands/chat.d.ts

@@ -185,7 +185,6 @@ export declare class ChatCommand {
      */
     private tryTemplateInstantPath;
     private tryDirectSingleFileFlow;
-    private isConfirmationFollowUp;
     private taskRequiresWorkspaceChanges;
     private getPreviousActionablePrompt;
     private buildContextualAgentPrompt;

package/dist/commands/chat.js

@@ -17,9 +17,10 @@ import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session
 import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
 import { looksLikeMarkdownReport, renderMarkdownToTerminal, summarizeMarkdownReport, } from '../utils/terminalMarkdown.js';
 import { emitDeckEvent, isDeckModeEnabled } from '../utils/deckEvents.js';
-import { inferAgentTaskType as sharedInferAgentTaskType, isTrivialHtmlPageRequest, resolvePlannerAgentTimeoutMs, resolveWorkflowType, shouldSkipAnalysisRescue, taskRequiresWorkspaceChanges as promptRequiresWorkspaceChanges, buildExecutionHints, isAgentContinuePrompt, isAgentRetryPrompt, isBuiltContinuePrompt, isBuiltRetryPrompt, } from '../utils/requestIntent.js';
+import { inferAgentTaskType as sharedInferAgentTaskType, inferAgentTaskTypeWithContext, isTrivialHtmlPageRequest, resolvePlannerAgentTimeoutMs, resolveWorkflowType, shouldSkipAnalysisRescue, taskRequiresWorkspaceChanges as promptRequiresWorkspaceChanges, taskRequiresWorkspaceChangesWithContext, buildExecutionHints, isAgentContinuePrompt, isAgentRetryPrompt, isBuiltContinuePrompt, isBuiltRetryPrompt, isBuiltWriteConfirmationPrompt, isConfirmationFollowUp, isWritePermissionGrant, } from '../utils/requestIntent.js';
 import { resolveAgentRoute } from '../utils/agentRoute.js';
 import { runTemplateInstantPath } from '../utils/templateInstantPath.js';
+import { isV3StreamKeepaliveEvent } from '../utils/v3-stream-events.js';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
@@ -979,6 +980,9 @@ export class ChatCommand {
             return;
         }
         this.v3LastActivity = Date.now();
+        if (isV3StreamKeepaliveEvent(event)) {
+            return;
+        }
         if (event.type === 'tool_call') {
             const eventKey = this.toolEventKey(event);
             if (this.v3SeenToolCalls.has(eventKey)) {
@@ -1138,11 +1142,6 @@ export class ChatCommand {
             const quality = this.sanitizeServerPath(plan.quality_profile || '');
             const status = typeof plan.status === 'string' ? plan.status : '';
             const summary = typeof plan.summary === 'string' ? this.sanitizeServerPath(plan.summary) : '';
-            if (status === 'planning') {
-                const elapsed = Number.isFinite(Number(plan.elapsed_seconds)) ? Number(plan.elapsed_seconds) : 0;
-                spinner.text = elapsed > 0 ? `Planning... (${elapsed}s elapsed)` : 'Planning...';
-                return;
-            }
             if (spinner.isSpinning)
                 spinner.stop();
             process.stdout.write(chalk.cyan(`  [Plan] `) + this.fitTerminalText(`Task: ${planKind || 'analyzing'}${quality ? ` (${quality})` : ''}`, 9) + '\n');
@@ -2044,7 +2043,22 @@ export class ChatCommand {
     }
     async runSimplePrompt(prompt) {
         if (!this.directPromptMode && !this.operatorMode) {
-            const promptToRun = this.isConfirmationFollowUp(prompt) && this.lastActionableUserInput && this.isRepoGroundedPrompt(this.lastActionableUserInput)
+            const isWriteFollowUp = isConfirmationFollowUp(prompt) || isWritePermissionGrant(prompt);
+            if (isWriteFollowUp && (this.lastActionableUserInput || this.getPreviousActionablePrompt())) {
+                if (!this.tools) {
+                    throw new Error('Agent tools are not initialized.');
+                }
+                this.agentMode = true;
+                this.syncInteractiveModeModel('agent');
+                if (this.currentSession) {
+                    this.currentSession.agentMode = true;
+                    this.currentSession.model = this.currentModel;
+                }
+                console.log(chalk.yellow('Write confirmation detected — switching to Agent mode with full file access.'));
+                await this.runAgentTurn(prompt);
+                return;
+            }
+            const promptToRun = isConfirmationFollowUp(prompt) && this.lastActionableUserInput && this.isRepoGroundedPrompt(this.lastActionableUserInput)
                 ? this.lastActionableUserInput
                 : prompt;
             if (this.isRepoGroundedPrompt(promptToRun) || /\b(build|implement|complete|fix|create|make|edit|write|change|finish)\b/i.test(promptToRun)) {
@@ -2215,7 +2229,7 @@ export class ChatCommand {
         await this.runLocalAgentLoop(resolvedPrompt);
     }
     resolveAgentTurnPrompt(prompt) {
-        if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt)) {
+        if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt) || isBuiltWriteConfirmationPrompt(prompt)) {
             return prompt;
         }
         if (isAgentContinuePrompt(prompt)) {
@@ -2236,6 +2250,15 @@ export class ChatCommand {
                 return followUp;
             }
         }
+        if ((isConfirmationFollowUp(prompt) || isWritePermissionGrant(prompt)) && !isAgentContinuePrompt(prompt)) {
+            const expanded = this.buildContextualAgentPrompt(prompt);
+            if (expanded !== prompt) {
+                if (!this.jsonOutput) {
+                    console.log(chalk.cyan('↪ Treating your message as write confirmation — applying the previous task with full write access.'));
+                }
+                return expanded;
+            }
+        }
         return prompt;
     }
     shouldPreserveBuildOutcomeForContinue(runPrompt, prior) {
@@ -2822,15 +2845,11 @@ export class ChatCommand {
         }
         return true;
     }
-    isConfirmationFollowUp(prompt) {
-        const normalized = prompt.trim().toLowerCase().replace(/[.!?]+$/g, '').replace(/\s+/g, ' ');
-        return /^(ja|ja bitte|ja bitte mach das|mach das|bitte mach das|genau|ok|okay|yes|yes please|please do|do it|go ahead|continue|proceed|make it so)$/.test(normalized);
-    }
     taskRequiresWorkspaceChanges(prompt) {
         return promptRequiresWorkspaceChanges(prompt);
     }
     getPreviousActionablePrompt() {
-        if (this.lastActionableUserInput && !this.isConfirmationFollowUp(this.lastActionableUserInput)) {
+        if (this.lastActionableUserInput && !isConfirmationFollowUp(this.lastActionableUserInput)) {
             return this.lastActionableUserInput;
         }
         for (let i = this.messages.length - 1; i >= 0; i -= 1) {
@@ -2838,7 +2857,9 @@ export class ChatCommand {
             if (message.role !== 'user')
                 continue;
             const content = (message.content || '').trim();
-            if (!content || this.isConfirmationFollowUp(content))
+            if (!content || isConfirmationFollowUp(content) || isWritePermissionGrant(content))
+                continue;
+            if (isBuiltWriteConfirmationPrompt(content) || isBuiltContinuePrompt(content) || isBuiltRetryPrompt(content))
                 continue;
             return content
                 .replace(/\n\nProject root:[\s\S]*$/i, '')
@@ -2848,7 +2869,7 @@ export class ChatCommand {
         return '';
     }
     buildContextualAgentPrompt(prompt) {
-        if (!this.isConfirmationFollowUp(prompt)) {
+        if (!isConfirmationFollowUp(prompt) && !isWritePermissionGrant(prompt)) {
             return prompt;
         }
         const previousPrompt = this.getPreviousActionablePrompt();
@@ -2856,13 +2877,14 @@ export class ChatCommand {
             return prompt;
         }
         return [
-            'The user confirmed the previous agent task. Continue and execute that original task now.',
+            'The user confirmed they want file changes applied. Execute the original task with full write access.',
             '',
             'Original task:',
             previousPrompt,
             '',
-            `Latest confirmation: ${prompt}`,
+            `User confirmation: ${prompt}`,
             '',
+            'Apply the requested file changes now. Do not stop at analysis or ask for permission again.',
             'Do not reinterpret this confirmation as a new website, landing page, template, or index.html task.',
         ].join('\n');
     }
@@ -2880,7 +2902,7 @@ export class ChatCommand {
         }
         const workspacePath = promptWorkspacePath || this.currentProjectPath;
         const contextualPrompt = this.buildContextualAgentPrompt(prompt);
-        if (contextualPrompt === prompt && !this.isConfirmationFollowUp(prompt)) {
+        if (contextualPrompt === prompt && !isConfirmationFollowUp(prompt) && !isWritePermissionGrant(prompt)) {
             this.lastActionableUserInput = prompt;
         }
         this.messages.push({ role: 'user', content: contextualPrompt });
@@ -2970,11 +2992,31 @@ export class ChatCommand {
             }
         };
         const executionPrompt = this.buildExecutionPrompt(contextualPrompt);
-        const agentTaskType = this.lastAgentRoute?.taskKind || this.inferAgentTaskType(prompt);
-        const workflowType = resolveWorkflowType(agentTaskType, prompt);
-        const executionHints = buildExecutionHints(agentTaskType, prompt, {
+        const priorPrompt = this.getPreviousActionablePrompt();
+        const intentContext = { priorPrompt: priorPrompt || null };
+        const classificationPrompt = contextualPrompt;
+        const agentTaskType = this.lastAgentRoute?.taskKind
+            || inferAgentTaskTypeWithContext(classificationPrompt, intentContext);
+        const workflowType = resolveWorkflowType(agentTaskType, classificationPrompt, intentContext);
+        const executionHints = buildExecutionHints(agentTaskType, classificationPrompt, {
             fastPath: this.lastAgentRoute?.fastPath,
+            priorPrompt: priorPrompt || null,
         });
+        const priorOutcome = this.lastAgentRunOutcome;
+        const resumeTaskIds = priorOutcome
+            ? [...new Set([...(priorOutcome.failedTaskIds || []), ...(priorOutcome.unfinishedTaskIds || [])])]
+            : [];
+        const shouldResumePlan = isAgentContinuePrompt(contextualPrompt)
+            || isAgentRetryPrompt(contextualPrompt)
+            || isBuiltContinuePrompt(contextualPrompt)
+            || isBuiltRetryPrompt(contextualPrompt);
+        const agentExecutionHints = shouldResumePlan
+            ? {
+                ...executionHints,
+                resume_existing_plan: true,
+                ...(resumeTaskIds.length > 0 ? { remaining_task_ids: resumeTaskIds } : {}),
+            }
+            : executionHints;
         const workspaceContext = {
             workspacePath: workspacePath,
             projectPath: workspacePath,
@@ -3011,7 +3053,7 @@ export class ChatCommand {
                 ...workspaceContext,
                 agentTaskType,
                 workflowType,
-                executionHints,
+                executionHints: agentExecutionHints,
                 fastPath: this.lastAgentRoute?.fastPath,
                 agentRoute: this.lastAgentRoute,
                 executionSurface: 'cli',
@@ -3029,20 +3071,15 @@ export class ChatCommand {
                 history: this.getMessagesForModel(),
                 ...runtimeContext,
                 onStreamEvent: (event) => {
+                    if (isV3StreamKeepaliveEvent(event)) {
+                        return;
+                    }
                     if (event.type === 'plan') {
-                        const plan = event?.plan || {};
-                        const isPlanningKeepalive = plan.status === 'planning' && !Array.isArray(plan.tasks);
-                        if (isPlanningKeepalive) {
-                            const elapsed = Number.isFinite(Number(plan.elapsed_seconds)) ? Number(plan.elapsed_seconds) : 0;
-                            taskDisplay.start(0, elapsed > 0 ? `planning (${elapsed}s)` : 'planning...');
-                        }
-                        else {
-                            taskDisplay.complete(0);
-                            const tasks = plan?.tasks;
-                            if (Array.isArray(tasks) && tasks.length > 0) {
-                                taskDisplay.start(1);
-                                liveOutcome.tasksTotal = tasks.length;
-                            }
+                        taskDisplay.complete(0);
+                        const tasks = event?.plan?.tasks;
+                        if (Array.isArray(tasks) && tasks.length > 0) {
+                            taskDisplay.start(1);
+                            liveOutcome.tasksTotal = tasks.length;
                         }
                     }
                     else if (event.type === 'executor_start') {
@@ -3085,10 +3122,19 @@ export class ChatCommand {
                     }
                     else if (event.type === 'error') {
                         const msg = typeof event.message === 'string' ? event.message : '';
-                        if (/plan|planner|dependency graph/i.test(msg)) {
+                        parsePlannerSummary(msg);
+                        const plannerSummary = /Planner-Executor completed/i.test(msg);
+                        const allTasksSucceeded = liveOutcome.tasksTotal > 0
+                            && liveOutcome.tasksSucceeded >= liveOutcome.tasksTotal
+                            && liveOutcome.failedTaskIds.size === 0;
+                        if (plannerSummary) {
+                            if (!allTasksSucceeded && !liveOutcome.plannerError) {
+                                liveOutcome.plannerError = msg;
+                            }
+                        }
+                        else 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)
@@ -3110,7 +3156,7 @@ export class ChatCommand {
             const previewGate = (response.metadata?.previewGate || null);
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
             const changedFileCount = response.changedFiles ? Object.keys(response.changedFiles).length : 0;
-            const requiresWorkspaceChanges = promptRequiresWorkspaceChanges(prompt);
+            const requiresWorkspaceChanges = taskRequiresWorkspaceChangesWithContext(contextualPrompt, intentContext);
             const answerContent = normalizeAgentAnswerContent(response.content, this.v3StreamedAnswerBuffer);
             liveOutcome.changedFileCount = changedFileCount;
             liveOutcome.requiresWorkspaceChanges = requiresWorkspaceChanges;
@@ -3472,7 +3518,9 @@ export class ChatCommand {
         this.v3StreamingStarted = false;
         this.v3StartSeen = false;
         try {
-            const retryTaskType = this.inferAgentTaskType(rawPrompt);
+            const retryPriorPrompt = this.getPreviousActionablePrompt();
+            const retryContext = { priorPrompt: retryPriorPrompt || null };
+            const retryTaskType = inferAgentTaskTypeWithContext(rawPrompt, retryContext);
             const retryResponse = await this.api.runV3AgentWorkflow(executionPrompt, {
                 workspace: { path: this.currentProjectPath },
                 ...workspaceContext,
@@ -3480,7 +3528,7 @@ export class ChatCommand {
                 clientSurface: 'cli',
                 localMachineCapable: true,
                 agentTaskType: retryTaskType,
-                workflowType: resolveWorkflowType(retryTaskType, rawPrompt),
+                workflowType: resolveWorkflowType(retryTaskType, rawPrompt, retryContext),
                 agentTimeoutMs: resolvePlannerAgentTimeoutMs(DEFAULT_V3_AGENT_TIMEOUT_MS, retryTaskType, rawPrompt),
                 agentIdleTimeoutMs: DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS,
                 agentSoftTimeoutMs: DEFAULT_V3_AGENT_SOFT_TIMEOUT_MS,

package/dist/utils/agentRunOutcome.js

@@ -206,6 +206,23 @@ export function evaluateExecutorSuccess(liveOutcome) {
         const allTasksPassed = liveOutcome.tasksSucceeded === liveOutcome.tasksTotal;
         const partialTasksPassed = liveOutcome.tasksSucceeded > 0;
         const failedCount = liveOutcome.failedTaskIds.size;
+        if (allTasksPassed && failedCount === 0 && !liveOutcome.streamAborted) {
+            const qualityOnlyPlannerNote = Boolean(liveOutcome.plannerError)
+                && /Planner-Executor completed:\s*\d+\s*\/\s*\d+\s+tasks succeeded/i.test(String(liveOutcome.plannerError));
+            const recoveredAfterTransientErrors = liveOutcome.executorFailed
+                || Boolean(liveOutcome.executorError)
+                || qualityOnlyPlannerNote;
+            if (!liveOutcome.plannerError || qualityOnlyPlannerNote || recoveredAfterTransientErrors) {
+                const qualityNote = qualityOnlyPlannerNote || /Quality (?:audit|blockers)/i.test(String(liveOutcome.plannerError || ''));
+                return {
+                    executorSucceeded: true,
+                    statusHeadline: qualityNote
+                        ? `✓ Tasks complete (${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal}) — quality audit below target`
+                        : `✓ Agent run finished (${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal} tasks completed)`,
+                    uiTheme: qualityNote ? 'warning' : 'success',
+                };
+            }
+        }
         if (allTasksPassed && !hasFatalError) {
             return {
                 executorSucceeded: true,

package/dist/utils/api.d.ts

@@ -272,6 +272,7 @@ export declare class APIClient {
      */
     isAnalysisOnlyTask(message?: string, context?: Record<string, any>): boolean;
     private normalizeWorkspaceRelativePath;
+    private collectAgentStateSyncPaths;
     private listFrontendWorkspaceFiles;
     private chooseFrontendPreviewEntry;
     private extractLinkedFrontendAssets;

package/dist/utils/api.js

@@ -14,6 +14,7 @@ import { getChangedFiles } from './workspace-cache.js';
 import { isSubstantiveAgentAnswer, isToolEvidenceStubAnswer } from './agentRunOutcome.js';
 import { joinV3WorkspacePath, normalizeV3WorkspaceRelativePath } from './v3-workspace-path.js';
 import { buildExecutionHints, isPlannerBuildTask, resolvePlannerAgentTimeoutMs } from './requestIntent.js';
+import { isV3StreamKeepaliveEvent } from './v3-stream-events.js';
 export const VIGTHORIA_HUB_CREDITS_URL = 'https://hub.vigthoria.io/credits';
 export const VIGTHORIA_SERVER_TEMPORARILY_UNAVAILABLE_MESSAGE = 'Vigthoria Server is temporarily not available. Please try again later. If the issue persists, please contact support.';
 export class CLIError extends Error {
@@ -732,6 +733,30 @@ export class APIClient {
     normalizeWorkspaceRelativePath(filePath) {
         return String(filePath || '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
     }
+    collectAgentStateSyncPaths(rootPath) {
+        const paths = [];
+        const progressPath = path.join(rootPath, '.vigthoria', 'agent-state', 'progress.json');
+        if (!fs.existsSync(progressPath)) {
+            return paths;
+        }
+        paths.push('.vigthoria/agent-state/progress.json');
+        const tasksDir = path.join(rootPath, '.vigthoria', 'agent-state', 'tasks');
+        if (!fs.existsSync(tasksDir)) {
+            return paths;
+        }
+        try {
+            for (const entry of fs.readdirSync(tasksDir, { withFileTypes: true })) {
+                if (!entry.isFile() || !entry.name.endsWith('.json')) {
+                    continue;
+                }
+                paths.push(`.vigthoria/agent-state/tasks/${entry.name}`);
+            }
+        }
+        catch {
+            // Ignore unreadable task snapshots.
+        }
+        return paths;
+    }
     listFrontendWorkspaceFiles(rootPath) {
         const results = [];
         const stack = [rootPath];
@@ -2401,7 +2426,8 @@ menu {
             };
             const snapshot = this.getAgentWorkspaceSnapshot(rootPath);
             const candidatePaths = snapshot.paths.filter((entry) => !/(^|[\/\\])\.vigthoria([\/\\]|$)/.test(entry));
-            let orderedPaths = candidatePaths;
+            const agentStatePaths = this.collectAgentStateSyncPaths(rootPath);
+            let orderedPaths = [...agentStatePaths, ...candidatePaths];
             try {
                 const ranked = buildSemanticContext(rootPath, requestFocus, 60).topFiles.map((file) => file.path);
                 const changes = getChangedFiles(rootPath, candidatePaths);
@@ -2478,7 +2504,9 @@ menu {
                 continue;
             if (/(^|[\/\\])\.(git|hg)([\/\\]|$)/.test(relativePath))
                 continue;
-            if (/(^|[\/\\])\.vigthoria([\/\\]|$)/.test(relativePath))
+            const normalizedPath = relativePath.replace(/\\/g, '/');
+            const isAgentStateSync = /^\.vigthoria\/agent-state\//i.test(normalizedPath);
+            if (!isAgentStateSync && /(^|[\/\\])\.vigthoria([\/\\]|$)/.test(relativePath))
                 continue;
             const absolutePath = path.join(rootPath, relativePath);
             try {
@@ -2646,6 +2674,18 @@ menu {
             }
             return;
         }
+        if (event.type === 'workspace_snapshot' && event.files && typeof event.files === 'object') {
+            for (const [rawPath, content] of Object.entries(event.files)) {
+                if (typeof content !== 'string') {
+                    continue;
+                }
+                const filePath = this.normalizeAgentWorkspaceRelativePath(rawPath, serverRoot || undefined);
+                if (filePath) {
+                    streamedFiles[filePath] = content;
+                }
+            }
+            return;
+        }
         // Only count confirmed mutations — not workspace snapshots (hydrated baseline)
         // or tool_call previews that may still fail client-side / read-only guards.
         if (event.type === 'tool_result' && event.success) {
@@ -2694,9 +2734,17 @@ menu {
         }
         return false;
     }
-    resolveV3ClientToolPath(rootPath, rawPath) {
-        const relativePath = this.normalizeAgentWorkspaceRelativePath(String(rawPath || '.'), rootPath);
-        if (!relativePath && String(rawPath || '.').trim() !== '.') {
+    resolveV3ClientToolPath(rootPath, rawPath, sourceRoots = []) {
+        const raw = String(rawPath || '.').trim();
+        const roots = [rootPath, ...sourceRoots.filter(Boolean)];
+        let relativePath = '';
+        for (const sourceRoot of roots) {
+            relativePath = this.normalizeAgentWorkspaceRelativePath(raw, sourceRoot);
+            if (relativePath || raw === '.' || raw === '') {
+                break;
+            }
+        }
+        if (!relativePath && raw !== '.' && raw !== '') {
             return null;
         }
         const absolutePath = relativePath ? joinV3WorkspacePath(rootPath, relativePath) : path.resolve(rootPath);
@@ -2747,7 +2795,8 @@ menu {
         }
         const name = String(event.name || event.tool || '').trim();
         const args = event.arguments || {};
-        const target = this.resolveV3ClientToolPath(rootPath, args.path || args.cwd || '.');
+        const serverRoot = String(context.__v3ServerWorkspaceRoot || '').trim();
+        const target = this.resolveV3ClientToolPath(rootPath, args.path || args.cwd || '.', serverRoot ? [serverRoot] : []);
         if (!target) {
             return { success: false, output: '', error: 'Tool path is outside the workspace.' };
         }
@@ -2831,6 +2880,14 @@ menu {
                         error: `File not found: ${target.relativePath}. Write the file before running syntax_check.`,
                     };
                 }
+                const stat = fs.statSync(target.absolutePath);
+                if (stat.isDirectory()) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `Expected a file, but path is a directory: ${target.relativePath}`,
+                    };
+                }
                 const ext = path.extname(target.absolutePath).toLowerCase();
                 if (ext === '.json') {
                     JSON.parse(fs.readFileSync(target.absolutePath, 'utf8'));
@@ -2851,12 +2908,19 @@ menu {
                 return { success: true, output: `Syntax check passed: ${target.relativePath}` };
             }
             if (name === 'run_command') {
-                const command = String(args.command || '').trim();
+                let command = String(args.command || '').trim();
                 if (!command)
                     return { success: false, output: '', error: 'run_command requires command.' };
+                if (process.platform === 'win32' && /^ls(\s|$)/i.test(command)) {
+                    command = command.replace(/^ls\b/i, 'dir');
+                }
                 const { exec } = await import('child_process');
                 return await new Promise((resolve) => {
-                    exec(command, { cwd: target.absolutePath, timeout: Number(args.timeout || 30000) }, (error, stdout, stderr) => {
+                    exec(command, {
+                        cwd: target.absolutePath,
+                        timeout: Number(args.timeout || 30000),
+                        shell: process.platform === 'win32' ? 'cmd.exe' : undefined,
+                    }, (error, stdout, stderr) => {
                         resolve({
                             success: !error,
                             output: String(stdout || stderr || '').slice(0, 12000),
@@ -3688,6 +3752,7 @@ document.addEventListener('DOMContentLoaded', () => {
                     }
                     if (!serverWorkspaceRoot && event.type === 'context' && typeof event.workspace_root === 'string' && event.workspace_root.trim()) {
                         serverWorkspaceRoot = event.workspace_root.trim();
+                        context.__v3ServerWorkspaceRoot = serverWorkspaceRoot;
                     }
                     if (event.type === 'client_tool_request') {
                         const toolTask = this.handleV3ClientToolRequest(event, context, response.url).catch((error) => {
@@ -3721,7 +3786,7 @@ document.addEventListener('DOMContentLoaded', () => {
                             }
                         }
                     }
-                    if (typeof context.onStreamEvent === 'function') {
+                    if (typeof context.onStreamEvent === 'function' && !isV3StreamKeepaliveEvent(userEvent)) {
                         try {
                             context.onStreamEvent(userEvent);
                         }

package/dist/utils/requestIntent.d.ts

@@ -2,6 +2,9 @@
  * Shared prompt intent detection for CLI routing, V3 hints, and rescue gating.
  * Keep aligned with V3-Code-Agent/agent.py _classify_request heuristics.
  */
+export type IntentContext = {
+    priorPrompt?: string | null;
+};
 /** Strip CLI-appended platform / mode shaping so it cannot flip quality profiles. */
 export declare function stripExecutionShaping(prompt: string): string;
 export declare function hasBuildVerb(prompt: string): boolean;
@@ -17,10 +20,20 @@ export declare function isContinueOrRetryPrompt(prompt: string): boolean;
 export declare function hasWebPageIntent(prompt: string): boolean;
 export declare function isTrivialHtmlPageRequest(prompt: string): boolean;
 export declare function hasCloneBuildIntent(prompt: string): boolean;
+export declare function isWritePermissionGrant(prompt: string): boolean;
+/** Short or extended confirmations that should chain to the prior actionable request. */
+export declare function isConfirmationFollowUp(prompt: string): boolean;
+/** True when the CLI expanded a write-confirmation follow-up for V3. */
+export declare function isBuiltWriteConfirmationPrompt(prompt: string): boolean;
+export declare function hasFixOrCorrectIntent(prompt: string): boolean;
+export declare function isReadOnlyCheckIntent(prompt: string): boolean;
 export declare function hasExplicitWriteIntent(prompt: string): boolean;
 export declare function taskRequiresWorkspaceChanges(prompt: string): boolean;
+export declare function resolveClassificationPrompt(prompt: string, context?: IntentContext): string;
+export declare function taskRequiresWorkspaceChangesWithContext(prompt: string, context?: IntentContext): boolean;
 export declare function hasAnalyzeAndBuildIntent(prompt: string): boolean;
 export declare function inferAgentTaskType(prompt: string): string;
+export declare function inferAgentTaskTypeWithContext(prompt: string, context?: IntentContext): string;
 export declare function shouldSkipAnalysisRescue(liveOutcome: {
     tasksTotal?: number;
     changedFileCount?: number;
@@ -29,9 +42,10 @@ export declare function shouldSkipAnalysisRescue(liveOutcome: {
 export declare function isPlannerBuildTask(agentTaskType: string, prompt: string): boolean;
 export declare function resolvePlannerAgentTimeoutMs(baseTimeoutMs: number, agentTaskType: string, prompt: string): number;
 /** V3 workflow mode: suppress write path when the user did not ask for file changes. */
-export declare function resolveWorkflowType(agentTaskType: string, prompt: string): 'analysis_only' | 'full';
+export declare function resolveWorkflowType(agentTaskType: string, prompt: string, context?: IntentContext): 'analysis_only' | 'full';
 export declare function buildExecutionHints(agentTaskType: string, prompt: string, options?: {
     fastPath?: string;
+    priorPrompt?: string | null;
 }): {
     task_kind: string;
     requires_file_changes: boolean | undefined;

package/dist/utils/requestIntent.js

@@ -11,8 +11,14 @@ const GAME_INTENT = /\b(game|spiel|playable|html5\s+(?:game|canvas)|html5\s+game
 const WEB_PAGE_INTENT = /\b(website|web\s*site|webpage|web\s*page|landing\s+page|home\s*page|index\.html|html\s+page|static\s+page|single\s+page|popup|alert|modal|hello\s+world)\b/i;
 const CLONE_BUILD = /\bclone\s+of\b|\b(build|create|make)\s+(?:a|an|the|us|me)?\s*(?:clone|replica|remake|port)\b/i;
 const READ_ONLY_INTENT = /\b(analy[sz]e|analyse|analysis|audit|review|inspect|proof|understand|summari[sz]e|scan|read[\s-]?only|where we left|what is|how does|show me|tell me|identify\s+gaps?|gap\s+analysis|production\s+blockers?)\b/i;
-const EXPLICIT_WRITE_VERBS = /\b(implement|write|edit|modify|update|fix|repair|create|build|generate|scaffold|deploy|refactor|develop|integrate)\b/i;
+const EXPLICIT_WRITE_VERBS = /\b(implement|write|edit|modify|update|fix|repair|create|build|generate|scaffold|deploy|refactor|develop|integrate|correct|apply|patch)\b/i;
 const TRIVIAL_HTML_PAGE = /\b(hello\s*world|simple\s+(?:html|web|page|site)|html5\s+website|html\s+5\s+website|popup|alert\s*\(|show\s+a\s+popup|one\s+page|single\s+html)\b/i;
+/** User explicitly grants write permission after an analysis or confirmation gate. */
+const WRITE_PERMISSION_GRANT = /\b(?:hereby\s+confirm|i\s+confirm|confirm(?:ed)?\s+that|give\s+(?:you|permission)|granting\s+permission|allow\s+(?:you|me\s+to)|you\s+(?:may|can|have\s+permission\s+to)|permission\s+to|authorized?\s+to|approve(?:d)?\s+(?:the\s+)?(?:changes?|writes?|edits?)|go\s+ahead\s+and(?:\s+write|\s+apply|\s+make|\s+do)?|do\s+all\s+the\s+changes|apply\s+(?:the\s+)?(?:changes?|fixes?|fix)|proceed\s+with\s+(?:the\s+)?(?:changes?|fixes?|implementation|writes?)|make\s+(?:the\s+)?changes|please\s+write)\b/i;
+/** Fix/correct/repair syntax or errors — write path without requiring artifact nouns. */
+const FIX_CORRECT_INTENT = /\b(correct|fix|repair|resolve|patch|address|remedy)\b[\s\S]{0,48}\b(syntax|errors?|bugs?|issues?|mistakes?|typos?)\b|\b(syntax|errors?|bugs?|issues?)\b[\s\S]{0,48}\b(correct|fix|repair|resolve|patch)\b/i;
+/** Read-only audit: check/review/find issues without an paired fix/implement verb nearby. */
+const READ_ONLY_CHECK = /\b(check|verify|audit|inspect|review|investigate|look\s+for|find|scan|validate|examine)\b[\s\S]{0,60}\b(syntax|errors?|bugs?|issues?|missing|gaps?|functionality)\b/i;
 /** Strip CLI-appended platform / mode shaping so it cannot flip quality profiles. */
 export function stripExecutionShaping(prompt) {
     return String(prompt || '')
@@ -120,8 +126,57 @@ export function isTrivialHtmlPageRequest(prompt) {
 export function hasCloneBuildIntent(prompt) {
     return CLONE_BUILD.test(stripExecutionShaping(prompt)) && hasBuildVerb(prompt);
 }
+export function isWritePermissionGrant(prompt) {
+    const text = stripExecutionShaping(prompt);
+    return WRITE_PERMISSION_GRANT.test(text)
+        || /\ballow\s+you\s+to\s+do\s+all\s+the\s+changes\b/i.test(text)
+        || /\b(?:i\s+)?(?:allow|permit)\s+you\s+to\s+write\b/i.test(text);
+}
+/** Short or extended confirmations that should chain to the prior actionable request. */
+export function isConfirmationFollowUp(prompt) {
+    const normalized = stripExecutionShaping(prompt).trim().toLowerCase().replace(/[.!?]+$/g, '').replace(/\s+/g, ' ');
+    if (!normalized) {
+        return false;
+    }
+    if (/^(ja|ja bitte|ja bitte mach das|mach das|bitte mach das|genau|ok|okay|yes|yes please|please do|do it|go ahead|continue|proceed|make it so)$/.test(normalized)) {
+        return true;
+    }
+    if (/^(please\s+)?(?:do\s+it|make\s+(?:the\s+)?changes|apply\s+(?:them|the\s+fixes|changes|the\s+fix)|fix\s+(?:them|it|now)|go\s+ahead)$/.test(normalized)) {
+        return true;
+    }
+    return isWritePermissionGrant(prompt);
+}
+/** True when the CLI expanded a write-confirmation follow-up for V3. */
+export function isBuiltWriteConfirmationPrompt(prompt) {
+    return /^The user confirmed they want file changes applied/i.test(stripExecutionShaping(prompt));
+}
+export function hasFixOrCorrectIntent(prompt) {
+    return FIX_CORRECT_INTENT.test(stripExecutionShaping(prompt));
+}
+export function isReadOnlyCheckIntent(prompt) {
+    const text = stripExecutionShaping(prompt);
+    if (!READ_ONLY_CHECK.test(text)) {
+        return false;
+    }
+    if (hasFixOrCorrectIntent(prompt) || isWritePermissionGrant(prompt)) {
+        return false;
+    }
+    if (/\b(?:fix|correct|repair|implement|apply|write|change|update)\b/i.test(text)) {
+        return false;
+    }
+    return true;
+}
 export function hasExplicitWriteIntent(prompt) {
     const text = stripExecutionShaping(prompt);
+    if (isWritePermissionGrant(prompt)) {
+        return true;
+    }
+    if (hasFixOrCorrectIntent(prompt)) {
+        return true;
+    }
+    if (isReadOnlyCheckIntent(prompt)) {
+        return false;
+    }
     return (BUILD_VERBS.test(text) && ARTIFACT_NOUNS.test(text))
         || hasCloneBuildIntent(prompt)
         || (BUILD_VERBS.test(text) && hasGameIntent(prompt));
@@ -129,13 +184,41 @@ export function hasExplicitWriteIntent(prompt) {
 export function taskRequiresWorkspaceChanges(prompt) {
     const text = String(prompt || '').trim();
     const shaped = stripExecutionShaping(text);
-    const readOnlyIntent = READ_ONLY_INTENT.test(shaped);
+    const readOnlyIntent = READ_ONLY_INTENT.test(shaped) || isReadOnlyCheckIntent(text);
     const explicitWriteIntent = hasExplicitWriteIntent(text);
     if (readOnlyIntent && !explicitWriteIntent) {
         return false;
     }
     return explicitWriteIntent;
 }
+export function resolveClassificationPrompt(prompt, context = {}) {
+    if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt) || isBuiltWriteConfirmationPrompt(prompt)) {
+        return prompt;
+    }
+    const prior = String(context.priorPrompt || '').trim();
+    if (prior && (isConfirmationFollowUp(prompt) || isWritePermissionGrant(prompt))) {
+        return `${prompt}\n\nPrior actionable request:\n${prior}`;
+    }
+    return prompt;
+}
+export function taskRequiresWorkspaceChangesWithContext(prompt, context = {}) {
+    if (isBuiltWriteConfirmationPrompt(prompt) || isWritePermissionGrant(prompt)) {
+        const prior = String(context.priorPrompt || '').trim();
+        if (prior) {
+            return true;
+        }
+        return isWritePermissionGrant(prompt);
+    }
+    const effective = resolveClassificationPrompt(prompt, context);
+    if (taskRequiresWorkspaceChanges(effective)) {
+        return true;
+    }
+    const prior = String(context.priorPrompt || '').trim();
+    if (prior && isConfirmationFollowUp(prompt)) {
+        return true;
+    }
+    return false;
+}
 export function hasAnalyzeAndBuildIntent(prompt) {
     const text = stripExecutionShaping(prompt);
     return /\b(analy[sz]e|analyse)\b/i.test(text)
@@ -144,6 +227,21 @@ export function hasAnalyzeAndBuildIntent(prompt) {
 }
 export function inferAgentTaskType(prompt) {
     const text = stripExecutionShaping(prompt);
+    if (isBuiltWriteConfirmationPrompt(prompt)) {
+        if (hasGameIntent(prompt)) {
+            return 'game-build';
+        }
+        if (hasFixOrCorrectIntent(prompt) || /\bsyntax\b/i.test(text)) {
+            return 'repair';
+        }
+        return 'implementation';
+    }
+    if (hasFixOrCorrectIntent(prompt)) {
+        if (hasGameIntent(prompt)) {
+            return 'game-build';
+        }
+        return 'repair';
+    }
     if (hasAnalyzeAndBuildIntent(prompt)) {
         if (hasGameIntent(prompt)) {
             return 'game-build';
@@ -153,7 +251,10 @@ export function inferAgentTaskType(prompt) {
         }
         return 'implementation';
     }
-    if (/\b(inspect|analyze|analyse|audit|review|find|diagnose|debug|trace|compare|diff|check|investigate)\b/i.test(text)
+    if (isReadOnlyCheckIntent(prompt)) {
+        return 'debugging';
+    }
+    if (/\b(inspect|analyze|analyse|audit|review|find|diagnose|debug|trace|compare|diff|investigate)\b/i.test(text)
         && !hasExplicitWriteIntent(prompt)) {
         return 'debugging';
     }
@@ -170,7 +271,31 @@ export function inferAgentTaskType(prompt) {
         }
         return 'implementation';
     }
-    return 'analysis';
+    if (hasExplicitWriteIntent(prompt)) {
+        return 'implementation';
+    }
+    return 'general';
+}
+export function inferAgentTaskTypeWithContext(prompt, context = {}) {
+    const prior = String(context.priorPrompt || '').trim();
+    if ((isConfirmationFollowUp(prompt) || isWritePermissionGrant(prompt) || isBuiltWriteConfirmationPrompt(prompt)) && prior) {
+        const priorType = inferAgentTaskType(prior);
+        if (isWritePermissionGrant(prompt) || isBuiltWriteConfirmationPrompt(prompt)) {
+            if (priorType === 'analysis' || priorType === 'debugging' || priorType === 'general') {
+                if (hasFixOrCorrectIntent(prior) || /\bsyntax\b/i.test(prior)) {
+                    return 'repair';
+                }
+                if (hasGameIntent(prior)) {
+                    return 'game-build';
+                }
+                return 'implementation';
+            }
+        }
+        if (priorType !== 'general') {
+            return priorType;
+        }
+    }
+    return inferAgentTaskType(resolveClassificationPrompt(prompt, context));
 }
 export function shouldSkipAnalysisRescue(liveOutcome) {
     if (liveOutcome.requiresWorkspaceChanges) {
@@ -209,25 +334,36 @@ export function resolvePlannerAgentTimeoutMs(baseTimeoutMs, agentTaskType, promp
     return Math.max(baseTimeoutMs, extended);
 }
 /** V3 workflow mode: suppress write path when the user did not ask for file changes. */
-export function resolveWorkflowType(agentTaskType, prompt) {
+export function resolveWorkflowType(agentTaskType, prompt, context = {}) {
+    if (isBuiltWriteConfirmationPrompt(prompt) || isWritePermissionGrant(prompt)) {
+        return 'full';
+    }
     if (hasAnalyzeAndBuildIntent(prompt)) {
         return 'full';
     }
     if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt)) {
-        return taskRequiresWorkspaceChanges(prompt) ? 'full' : 'analysis_only';
+        return taskRequiresWorkspaceChangesWithContext(prompt, context) ? 'full' : 'analysis_only';
+    }
+    const prior = String(context.priorPrompt || '').trim();
+    if (prior && isConfirmationFollowUp(prompt)) {
+        return 'full';
     }
-    if (!taskRequiresWorkspaceChanges(prompt)) {
+    if (!taskRequiresWorkspaceChangesWithContext(prompt, context)) {
         return 'analysis_only';
     }
     const kind = String(agentTaskType || '').toLowerCase();
-    if (kind === 'analysis' || kind === 'debugging' || kind === 'verification') {
+    if ((kind === 'analysis' || kind === 'debugging' || kind === 'verification')
+        && !hasFixOrCorrectIntent(prompt)
+        && !isWritePermissionGrant(prompt)) {
         return 'analysis_only';
     }
     return 'full';
 }
 export function buildExecutionHints(agentTaskType, prompt, options = {}) {
-    const workflowType = resolveWorkflowType(agentTaskType, prompt);
-    const kind = String(agentTaskType || 'general').toLowerCase();
+    const context = { priorPrompt: options.priorPrompt ?? null };
+    const effectiveTaskType = inferAgentTaskTypeWithContext(prompt, context);
+    const workflowType = resolveWorkflowType(effectiveTaskType, prompt, context);
+    const kind = String(effectiveTaskType || agentTaskType || 'general').toLowerCase();
     const hints = {
         task_kind: kind,
         requires_file_changes: workflowType === 'analysis_only' ? false : undefined,

package/dist/utils/v3-stream-events.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detect V3 agent SSE keepalive/heartbeat events that exist only to keep
+ * connections alive — not substantive work the CLI should surface as progress.
+ */
+export declare function isV3StreamKeepaliveEvent(event: unknown): boolean;

package/dist/utils/v3-stream-events.js

@@ -0,0 +1,41 @@
+/**
+ * Detect V3 agent SSE keepalive/heartbeat events that exist only to keep
+ * connections alive — not substantive work the CLI should surface as progress.
+ */
+const PLANNING_KEEPALIVE = /^Planning in progress\.\.\.\s*\(\d+s(?:\s+elapsed)?\)$/i;
+const PARALLEL_KEEPALIVE = /^Parallel tasks in progress\.\.\.\s*\(\d+s(?:\s+elapsed)?\)$/i;
+const GENERIC_ELAPSED_KEEPALIVE = /\bin progress\b.*\(\d+s(?:\s+elapsed)?\)$/i;
+export function isV3StreamKeepaliveEvent(event) {
+    if (!event || typeof event !== 'object') {
+        return false;
+    }
+    const record = event;
+    const type = typeof record.type === 'string' ? record.type : '';
+    if (type === 'heartbeat') {
+        return true;
+    }
+    if (type === 'progress' || type === 'status') {
+        const content = String(record.content || record.message || record.status || '').trim();
+        if (!content) {
+            return false;
+        }
+        if (PLANNING_KEEPALIVE.test(content) || PARALLEL_KEEPALIVE.test(content)) {
+            return true;
+        }
+        if (GENERIC_ELAPSED_KEEPALIVE.test(content)) {
+            return true;
+        }
+    }
+    if (type === 'plan') {
+        const plan = record.plan;
+        if (plan && typeof plan === 'object') {
+            const planRecord = plan;
+            const status = typeof planRecord.status === 'string' ? planRecord.status : '';
+            const tasks = planRecord.tasks;
+            if (status === 'planning' && !Array.isArray(tasks)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/utils/v3-workspace-path.js

@@ -42,6 +42,36 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
         }
         return null;
     };
+    const stripScrubbedPlaceholder = (value) => {
+        const candidate = String(value || '').replace(/^\/+/, '');
+        const placeholderPatterns = [
+            [/^(?:var\/)?www\/\[internal\](?:\/(.*))?$/i, 1],
+            [/^\[internal\](?:\/(.*))?$/i, 1],
+            [/^\[Vigthoria service\](?:\/(.*))?$/i, 1],
+            [/^\[Vigthoria Agent\](?:\/(.*))?$/i, 1],
+            [/^\[Vigthoria storage\](?:\/(.*))?$/i, 1],
+            [/^\[temp\](?:\/(.*))?$/i, 1],
+            [/^\[home\](?:\/(.*))?$/i, 1],
+            [/^\[workspace\](?:\/(.*))?$/i, 1],
+            [/^(?:var\/)?www\/\[Vigthoria service\](?:\/(.*))?$/i, 1],
+        ];
+        for (const [pattern, groupIndex] of placeholderPatterns) {
+            const match = candidate.match(pattern);
+            if (match) {
+                return safeRelative(match[groupIndex] || '');
+            }
+        }
+        const bracketSplit = candidate.split(/\[(?:internal|Vigthoria service|Vigthoria Agent|temp|home|workspace)\]/i);
+        if (bracketSplit.length > 1) {
+            const tail = bracketSplit[bracketSplit.length - 1].replace(/^\/+/, '');
+            return safeRelative(tail);
+        }
+        return null;
+    };
+    const scrubbed = stripScrubbedPlaceholder(input);
+    if (scrubbed !== null) {
+        return scrubbed;
+    }
     const decoded = decodeBoundaryUri(input);
     if (decoded !== null) {
         return decoded;
@@ -72,6 +102,18 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
     }
     const normalizedRoot = String(rootPath || '').trim().replace(/\\/g, '/').replace(/\/+$/g, '');
     if (normalizedRoot) {
+        if (/^[a-zA-Z]:\//.test(input)) {
+            const winRoot = normalizedRoot;
+            const inputLower = input.toLowerCase();
+            const winRootLower = winRoot.toLowerCase();
+            if (inputLower === winRootLower || inputLower === `${winRootLower}/`) {
+                return '';
+            }
+            if (inputLower.startsWith(`${winRootLower}/`)) {
+                return safeRelative(input.slice(winRoot.length + 1));
+            }
+            return '';
+        }
         const rootNoLeadingSlash = normalizedRoot.replace(/^\//, '');
         const rootBase = path.posix.basename(normalizedRoot);
         const prefixes = [
@@ -90,7 +132,11 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
             return safeRelative(input.slice(embeddedIndex + embeddedRoot.length));
         }
     }
-    return safeRelative(input);
+    const relative = safeRelative(input);
+    if (relative === 'workspace') {
+        return '';
+    }
+    return relative;
 }
 /** Join workspace root + relative path without path.resolve URI corruption on Windows. */
 export function joinV3WorkspacePath(rootPath, relativePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.11.28",
+  "version": "1.11.31",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -68,7 +68,8 @@
     "test:model:governance": "npm run build && node scripts/test-model-governance-no-agent.js",
     "validate:no-go": "bash scripts/release/validate-no-go-gates.sh",
     "test:legion:billing:e2e": "npm run build && node scripts/test-legion-godmode-billing-e2e.js",
-    "test:windows:v3-sync": "npm run build && node scripts/test-windows-v3-sync-recovery.js"
+    "test:windows:v3-sync": "npm run build && node scripts/test-windows-v3-sync-recovery.js",
+    "test:v3-workspace-path": "npm run build && node scripts/test-v3-workspace-path.js"
   },
   "keywords": [
     "ai",

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

@@ -97,9 +97,23 @@ python3 - << 'PY'
 import json
 ids={m.get('id','') for m in json.load(open('/tmp/vig-models.json')).get('data',[])}
 if ids:
-  assert ('vigthoria-balanced-4b' in ids) or ('vigthoria-balanced-4b:latest' in ids) or ('vigthoria-v3-balanced-4b' in ids) or ('vigthoria-v3-balanced-4b:latest' in ids)
-  assert 'vigthoria-creative-9b-v4' in ids
-  assert any('vigthoria-v3-code-35b' in i for i in ids)
+  has_router = any(
+    m in ids for m in (
+      'vigthoria-balanced-4b', 'vigthoria-balanced-4b:latest',
+      'vigthoria-v3-balanced-4b', 'vigthoria-v3-balanced-4b:latest',
+      'vigthoria-fast-9b', 'vigthoria-fast-9b:latest',
+    )
+  )
+  has_creative = any(
+    m in ids for m in (
+      'vigthoria-creative-9b-v4', 'vigthoria-creative-9b-v4:latest',
+      'vigthoria-fast-9b', 'vigthoria-fast-9b:latest',
+    )
+  )
+  has_code = any('vigthoria-v3-code-35b' in i for i in ids)
+  assert has_router, f'missing router model in inventory: {sorted(ids)}'
+  assert has_creative, f'missing creative/fast model in inventory: {sorted(ids)}'
+  assert has_code, f'missing code model in inventory: {sorted(ids)}'
 else:
   print('[warn] model inventory empty on this host; route proof above is authoritative')
 print('[pass] model inventory gates')