vigthoria-cli 1.6.9 → 1.6.13

package/dist/commands/chat.js

@@ -40,6 +40,7 @@ exports.ChatCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 const api_js_1 = require("../utils/api.js");
@@ -64,11 +65,29 @@ class ChatCommand {
     directPromptMode = false;
     directToolContinuationCount = 0;
     currentModel = 'code';
+    modelExplicitlySelected = false;
     autoApprove = false;
     operatorMode = false;
     workflowTarget = null;
     savePlanToVigFlow = false;
     jsonOutput = false;
+    syncInteractiveModeModel(enabledMode) {
+        if (enabledMode === 'agent') {
+            if (!this.modelExplicitlySelected || this.currentModel === 'code' || !this.currentModel) {
+                this.currentModel = 'agent';
+            }
+            return;
+        }
+        if (enabledMode === 'operator') {
+            if (this.currentModel === 'agent' || !this.currentModel) {
+                this.currentModel = 'code-8b';
+            }
+            return;
+        }
+        if (this.currentModel === 'agent' || this.currentModel === 'code-8b' || !this.currentModel) {
+            this.currentModel = 'code';
+        }
+    }
     hasOperatorAccess() {
         return this.config.hasOperatorAccess();
     }
@@ -76,6 +95,73 @@ class ChatCommand {
         const currentPlan = this.config.get('subscription').plan || 'free';
         return `Operator mode requires Enterprise or admin access. Current plan: ${currentPlan}.`;
     }
+    getDefaultChatModel() {
+        const preferredModel = String(this.config.get('preferences').defaultModel || '').trim().toLowerCase();
+        if (!preferredModel || preferredModel === 'vigthoria-code' || preferredModel === 'vigthoria-agent') {
+            return 'code';
+        }
+        return preferredModel;
+    }
+    resolveInitialModel(options) {
+        const requestedModel = String(options.model || '').trim();
+        if (requestedModel) {
+            return requestedModel;
+        }
+        if (options.operator === true) {
+            return 'code-8b';
+        }
+        if (options.agent === true) {
+            return 'agent';
+        }
+        return this.getDefaultChatModel();
+    }
+    isLegacyAgentFallbackAllowed() {
+        return process.env.VIGTHORIA_ALLOW_LEGACY_AGENT_FALLBACK === '1';
+    }
+    resolveAgentExecutionPolicy(prompt) {
+        const explicitModel = this.modelExplicitlySelected;
+        const heavyTask = this.config.isComplexTask(prompt);
+        const cloudEligible = this.config.hasCloudAccess() && this.hasOperatorAccess();
+        const requiresV3Workflow = this.shouldRequireV3AgentWorkflow(prompt);
+        if (explicitModel) {
+            return {
+                selectedModel: this.currentModel,
+                explicitModel: true,
+                heavyTask,
+                cloudEligible,
+                cloudSelected: this.currentModel === 'cloud' || this.currentModel === 'cloud-reason' || this.currentModel === 'ultra',
+                routeReason: 'explicit-model-selection',
+            };
+        }
+        if (requiresV3Workflow) {
+            return {
+                selectedModel: 'agent',
+                explicitModel: false,
+                heavyTask,
+                cloudEligible,
+                cloudSelected: false,
+                routeReason: 'v3-required-frontend-task',
+            };
+        }
+        if (this.config.shouldUseCloudForHeavyTask(prompt)) {
+            return {
+                selectedModel: 'cloud',
+                explicitModel: false,
+                heavyTask: true,
+                cloudEligible: true,
+                cloudSelected: true,
+                routeReason: 'heavy-enterprise-task',
+            };
+        }
+        return {
+            selectedModel: 'agent',
+            explicitModel: false,
+            heavyTask,
+            cloudEligible,
+            cloudSelected: false,
+            routeReason: 'default-v3-agent',
+        };
+    }
     getMessagesForModel() {
         const memoryContext = this.sessionManager.buildMemoryContext(this.currentSession);
         const messages = [...this.messages];
@@ -218,9 +304,10 @@ class ChatCommand {
             : null;
         this.savePlanToVigFlow = options.savePlan === true;
         this.jsonOutput = options.json === true;
-        this.autoApprove = options.autoApprove === true;
-        this.currentModel = options.model || 'code';
-        this.currentProjectPath = path.resolve(options.project || process.cwd());
+        this.autoApprove = options.autoApprove === true || this.jsonOutput;
+        this.modelExplicitlySelected = Boolean(String(options.model || '').trim());
+        this.currentModel = this.resolveInitialModel(options);
+        this.currentProjectPath = this.resolveProjectPath(options);
         if (this.jsonOutput && !options.prompt) {
             throw new Error('--json is only supported together with --prompt.');
         }
@@ -253,6 +340,77 @@ class ChatCommand {
         }
         fs.mkdirSync(this.currentProjectPath, { recursive: true });
     }
+    resolveProjectPath(options) {
+        const requestedProject = String(options.project || '').trim();
+        if (requestedProject) {
+            return path.resolve(requestedProject);
+        }
+        if (this.shouldUseManagedWorkspace(options)) {
+            const rootPath = this.getManagedWorkspaceRoot();
+            fs.mkdirSync(rootPath, { recursive: true });
+            const folderName = this.resolveManagedWorkspaceName(options);
+            const projectPath = this.allocateManagedWorkspacePath(rootPath, folderName);
+            this.config.set('project', {
+                ...this.config.get('project'),
+                rootPath,
+            });
+            return projectPath;
+        }
+        return process.cwd();
+    }
+    shouldUseManagedWorkspace(options) {
+        if (options.projectProvided) {
+            return false;
+        }
+        if (options.newProject) {
+            return true;
+        }
+        return Boolean(options.prompt) && (options.agent === true || options.operator === true);
+    }
+    getManagedWorkspaceRoot() {
+        const envRoot = String(process.env.VIGTHORIA_DEFAULT_WORKSPACE_ROOT || '').trim();
+        const configuredRoot = String(this.config.get('project').rootPath || '').trim();
+        return path.resolve(envRoot || configuredRoot || path.join(os.homedir(), 'VigthoriaProjects'));
+    }
+    resolveManagedWorkspaceName(options) {
+        const explicitName = typeof options.newProject === 'string' ? options.newProject.trim() : '';
+        if (explicitName) {
+            return this.slugifyWorkspaceName(explicitName);
+        }
+        if (options.prompt) {
+            const fromPrompt = this.slugifyWorkspaceName(options.prompt.split(/[.!?\n]/)[0] || 'project');
+            if (fromPrompt) {
+                return fromPrompt;
+            }
+        }
+        return `project-${new Date().toISOString().replace(/[-:TZ.]/g, '').slice(0, 14)}`;
+    }
+    slugifyWorkspaceName(input) {
+        return String(input || '')
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .slice(0, 48) || 'project';
+    }
+    allocateManagedWorkspacePath(rootPath, folderName) {
+        const basePath = path.join(rootPath, folderName);
+        if (!fs.existsSync(basePath)) {
+            return basePath;
+        }
+        const existingEntries = fs.readdirSync(basePath);
+        if (existingEntries.length === 0) {
+            return basePath;
+        }
+        let counter = 2;
+        while (counter < 1000) {
+            const candidate = path.join(rootPath, `${folderName}-${counter}`);
+            if (!fs.existsSync(candidate)) {
+                return candidate;
+            }
+            counter += 1;
+        }
+        return path.join(rootPath, `${folderName}-${Date.now()}`);
+    }
     initializeSession(resume) {
         if (resume) {
             this.currentSession = this.sessionManager.getLatest(this.currentProjectPath);
@@ -469,16 +627,34 @@ class ChatCommand {
         if (!this.tools) {
             throw new Error('Agent tools are not initialized.');
         }
+        const requiresV3Workflow = this.shouldRequireV3AgentWorkflow(prompt);
         const handledByDirectFileFlow = await this.tryDirectSingleFileFlow(prompt);
         if (handledByDirectFileFlow) {
             this.saveSession();
             return;
         }
+        if (this.shouldPreferLocalAgentLoop(prompt)) {
+            await this.runLocalAgentLoop(prompt);
+            return;
+        }
         const handledByV3Workflow = await this.tryV3AgentWorkflow(prompt);
         if (handledByV3Workflow) {
             this.saveSession();
             return;
         }
+        if (requiresV3Workflow) {
+            const errorMessage = 'This task requires the V3 agent workflow and the CLI will not fall back to the legacy local agent loop.';
+            this.logger.error(errorMessage);
+            this.messages.push({ role: 'assistant', content: errorMessage });
+            this.saveSession();
+            return;
+        }
+        await this.runLocalAgentLoop(prompt);
+    }
+    async runLocalAgentLoop(prompt) {
+        if (!this.tools) {
+            throw new Error('Agent tools are not initialized.');
+        }
         this.lastActionableUserInput = prompt;
         this.directToolContinuationCount = 0;
         this.tools.clearSessionApprovals();
@@ -496,7 +672,22 @@ class ChatCommand {
                 const toolCalls = this.extractToolCalls(assistantMessage);
                 const visibleText = this.stripToolPayloads(assistantMessage).trim();
                 if (toolCalls.length === 0) {
-                    console.log(visibleText || 'Task complete.');
+                    const finalContent = this.resolveDirectModeCompletion(prompt, visibleText);
+                    if (this.jsonOutput) {
+                        console.log(JSON.stringify({
+                            success: true,
+                            mode: 'agent',
+                            model: this.currentModel,
+                            partial: false,
+                            content: finalContent,
+                            metadata: {
+                                executionPath: 'local-agent-loop',
+                            },
+                        }, null, 2));
+                    }
+                    else {
+                        console.log(finalContent);
+                    }
                     this.saveSession();
                     return;
                 }
@@ -510,11 +701,41 @@ class ChatCommand {
             }
             catch (error) {
                 spinner.fail('Agent request failed');
+                if (this.jsonOutput) {
+                    process.exitCode = 1;
+                    console.log(JSON.stringify({
+                        success: false,
+                        mode: 'agent',
+                        model: this.currentModel,
+                        partial: false,
+                        content: '',
+                        error: error.message,
+                        metadata: {
+                            executionPath: 'local-agent-loop',
+                        },
+                    }, null, 2));
+                }
                 this.logger.error(error.message);
                 return;
             }
         }
-        console.log('Task complete.');
+        if (this.jsonOutput) {
+            process.exitCode = 1;
+            console.log(JSON.stringify({
+                success: false,
+                mode: 'agent',
+                model: this.currentModel,
+                partial: true,
+                content: 'Task complete.',
+                error: 'Agent exhausted the maximum local tool loop turns before reaching a clean completion.',
+                metadata: {
+                    executionPath: 'local-agent-loop',
+                },
+            }, null, 2));
+        }
+        else {
+            console.log('Task complete.');
+        }
         this.saveSession();
     }
     async tryDirectSingleFileFlow(prompt) {
@@ -525,41 +746,51 @@ class ChatCommand {
         if (!targetFile) {
             return false;
         }
+        if (this.shouldBypassDirectSingleFileFlow(targetFile, prompt)) {
+            return false;
+        }
         const readCall = {
             tool: 'read_file',
             args: { path: targetFile },
         };
-        console.log(chalk_1.default.cyan(`⚙ Executing: ${readCall.tool}`));
+        if (!this.jsonOutput) {
+            console.log(chalk_1.default.cyan(`⚙ Executing: ${readCall.tool}`));
+        }
         const readResult = await this.tools.execute(readCall);
         const readSummary = this.formatToolResult(readCall, readResult);
-        console.log(readResult.success ? chalk_1.default.gray(readSummary) : chalk_1.default.red(readSummary));
+        if (!this.jsonOutput) {
+            console.log(readResult.success ? chalk_1.default.gray(readSummary) : chalk_1.default.red(readSummary));
+        }
         this.messages.push({ role: 'system', content: readSummary });
         if (!readResult.success || !readResult.output) {
             return false;
         }
-        const rewriteMessages = [
-            {
-                role: 'system',
-                content: [
-                    'You are repairing a single file for a CLI agent task.',
-                    `Return only the final contents for ${targetFile}.`,
-                    'Do not use Markdown fences.',
-                    'Do not add explanations before or after the file contents.',
-                    'Produce complete, runnable code or markup.',
-                ].join('\n'),
-            },
-            {
-                role: 'user',
-                content: [
-                    `Task: ${prompt}`,
-                    `Target file: ${targetFile}`,
-                    'Current file contents:',
-                    readResult.output,
-                ].join('\n\n'),
-            },
-        ];
-        const rewriteResponse = await this.api.chat(rewriteMessages, this.currentModel);
-        const rewrittenContent = this.extractFinalFileContent(rewriteResponse.message, targetFile);
+        let rewrittenContent = this.tryDeterministicSingleFileRewrite(prompt, targetFile, readResult.output);
+        if (!rewrittenContent) {
+            const rewriteMessages = [
+                {
+                    role: 'system',
+                    content: [
+                        'You are repairing a single file for a CLI agent task.',
+                        `Return only the final contents for ${targetFile}.`,
+                        'Do not use Markdown fences.',
+                        'Do not add explanations before or after the file contents.',
+                        'Produce complete, runnable code or markup.',
+                    ].join('\n'),
+                },
+                {
+                    role: 'user',
+                    content: [
+                        `Task: ${prompt}`,
+                        `Target file: ${targetFile}`,
+                        'Current file contents:',
+                        readResult.output,
+                    ].join('\n\n'),
+                },
+            ];
+            const rewriteResponse = await this.api.chat(rewriteMessages, this.currentModel);
+            rewrittenContent = this.extractFinalFileContent(rewriteResponse.message, targetFile);
+        }
         if (!rewrittenContent) {
             return false;
         }
@@ -570,55 +801,133 @@ class ChatCommand {
                 content: rewrittenContent,
             },
         };
-        console.log(chalk_1.default.cyan(`⚙ Executing: ${writeCall.tool}`));
+        if (!this.jsonOutput) {
+            console.log(chalk_1.default.cyan(`⚙ Executing: ${writeCall.tool}`));
+        }
         const writeResult = await this.tools.execute(writeCall);
         const writeSummary = this.formatToolResult(writeCall, writeResult);
-        console.log(writeResult.success ? chalk_1.default.gray(writeSummary) : chalk_1.default.red(writeSummary));
+        if (!this.jsonOutput) {
+            console.log(writeResult.success ? chalk_1.default.gray(writeSummary) : chalk_1.default.red(writeSummary));
+        }
         this.messages.push({ role: 'system', content: writeSummary });
         if (!writeResult.success) {
             return false;
         }
-        console.log(`Updated ${targetFile}.`);
+        const previewGate = await this.api.runTemplateServicePreviewGate(prompt, {
+            workspacePath: this.currentProjectPath,
+            projectPath: this.currentProjectPath,
+            targetPath: this.currentProjectPath,
+            rawPrompt: prompt,
+            executionSurface: 'cli',
+            clientSurface: 'cli',
+        });
+        const success = previewGate.required ? previewGate.passed === true : true;
+        if (!success) {
+            process.exitCode = 1;
+        }
+        if (this.jsonOutput) {
+            console.log(JSON.stringify({
+                success,
+                mode: 'agent',
+                model: this.currentModel,
+                partial: false,
+                content: `Updated ${targetFile}.`,
+                metadata: {
+                    executionPath: 'direct-single-file',
+                    targetFile,
+                    previewGate,
+                },
+            }, null, 2));
+        }
+        else {
+            console.log(`Updated ${targetFile}.`);
+            if (previewGate.required) {
+                if (previewGate.passed) {
+                    console.log(chalk_1.default.gray(`Template Service preview gate: passed via ${previewGate.backendUrl || 'unknown backend'}`));
+                }
+                else {
+                    console.log(chalk_1.default.yellow(`Template Service preview gate: failed${previewGate.error ? ` - ${previewGate.error}` : ''}`));
+                }
+            }
+        }
         return true;
     }
     async tryV3AgentWorkflow(prompt) {
         const runtimeContext = await this.getPromptRuntimeContext(prompt);
-        const spinner = this.jsonOutput ? null : (0, ora_1.default)({ text: 'Thinking...', spinner: 'clock' }).start();
+        const routingPolicy = this.resolveAgentExecutionPolicy(prompt);
+        const rescueEligible = this.isSaaSRescuePrompt(prompt);
+        const spinner = this.jsonOutput ? null : (0, ora_1.default)({
+            text: routingPolicy.cloudSelected ? 'Routing heavy task to Vigthoria Cloud...' : 'Routing to V3 Agent...',
+            spinner: 'clock',
+        }).start();
         const executionPrompt = this.buildExecutionPrompt(prompt);
         const agentTaskType = this.inferAgentTaskType(prompt);
+        const workspaceContext = {
+            workspacePath: this.currentProjectPath,
+            projectPath: this.currentProjectPath,
+            targetPath: this.currentProjectPath,
+            ...runtimeContext,
+        };
         try {
-            const response = await this.api.runV3AgentWorkflow(executionPrompt, {
+            const workflowPromise = this.api.runV3AgentWorkflow(executionPrompt, {
                 workspace: { path: this.currentProjectPath },
-                workspacePath: this.currentProjectPath,
-                projectPath: this.currentProjectPath,
-                targetPath: this.currentProjectPath,
+                ...workspaceContext,
                 agentTaskType,
                 executionSurface: 'cli',
                 clientSurface: 'cli',
                 localMachineCapable: true,
                 agentTimeoutMs: DEFAULT_V3_AGENT_TIMEOUT_MS,
                 agentIdleTimeoutMs: 90000,
+                model: routingPolicy.selectedModel,
+                requestedModel: this.currentModel,
+                agentExecutionPolicy: routingPolicy,
+                legacyFallbackAllowed: this.isLegacyAgentFallbackAllowed(),
                 rawPrompt: prompt,
                 history: this.getMessagesForModel(),
                 ...runtimeContext,
                 onStreamEvent: spinner ? (event) => this.updateV3AgentSpinner(spinner, event) : undefined,
             });
+            const response = await (rescueEligible
+                ? Promise.race([
+                    workflowPromise,
+                    new Promise((_, reject) => {
+                        setTimeout(() => reject(new Error('V3_SAAS_SOFT_TIMEOUT')), 240000);
+                    }),
+                ])
+                : workflowPromise);
             if (spinner) {
                 spinner.stop();
             }
             const previewGate = (response.metadata?.previewGate || null);
-            const success = previewGate?.required === true ? previewGate?.passed === true : true;
+            const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
+            const success = previewGate?.required === true
+                ? (previewGate?.passed === true || workspaceHasOutput)
+                : true;
             if (!success) {
+                if (this.isLegacyAgentFallbackAllowed()) {
+                    if (spinner) {
+                        spinner.warn('Falling back to legacy CLI agent loop');
+                    }
+                    this.logger.debug(`V3 agent workflow returned an incomplete result: ${previewGate?.error || 'workspace changes were not fully validated'}`);
+                    return false;
+                }
+                const errorMessage = `V3 agent workflow returned an incomplete result and legacy fallback is disabled. ${previewGate?.error || 'Workspace changes were not fully validated.'}`;
                 if (spinner) {
-                    spinner.warn('Falling back to legacy CLI agent loop');
+                    spinner.fail('V3 agent workflow rejected the result');
                 }
-                this.logger.debug(`V3 agent workflow returned an incomplete result: ${previewGate?.error || 'workspace changes were not fully validated'}`);
-                return false;
+                this.logger.error(errorMessage);
+                this.messages.push({ role: 'assistant', content: errorMessage });
+                return true;
+            }
+            if (!this.jsonOutput && previewGate?.required && previewGate?.passed !== true && workspaceHasOutput) {
+                console.log(chalk_1.default.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,
@@ -627,9 +936,11 @@ class ChatCommand {
                 }, null, 2));
             }
             else if (response.content) {
+                console.log(chalk_1.default.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'} via model ${routingPolicy.selectedModel}`));
                 console.log(response.content);
             }
             else {
+                console.log(chalk_1.default.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'} via model ${routingPolicy.selectedModel}`));
                 console.log('V3 agent workflow completed.');
             }
             if (!this.jsonOutput && previewGate?.required) {
@@ -644,12 +955,82 @@ class ChatCommand {
             return true;
         }
         catch (error) {
+            if (rescueEligible && !this.api.hasAgentWorkspaceOutput(workspaceContext)) {
+                const rescued = await this.tryCommandLevelSaaSRescue(executionPrompt, prompt, workspaceContext, routingPolicy, spinner, error);
+                if (rescued) {
+                    return true;
+                }
+            }
+            if (this.isLegacyAgentFallbackAllowed()) {
+                if (spinner) {
+                    spinner.warn('Falling back to legacy CLI agent loop');
+                }
+                this.logger.debug(`V3 agent workflow unavailable: ${error.message}`);
+                return false;
+            }
             if (spinner) {
-                spinner.warn('Falling back to legacy CLI agent loop');
+                spinner.fail('V3 agent workflow failed');
             }
-            this.logger.debug(`V3 agent workflow unavailable: ${error.message}`);
+            const errorMessage = `Agent mode requires the V3 workflow and will not fall back to the legacy CLI loop. ${error.message}`;
+            this.logger.error(errorMessage);
+            this.messages.push({ role: 'assistant', content: errorMessage });
+            return true;
+        }
+    }
+    isSaaSRescuePrompt(prompt) {
+        return /(saas|dashboard|analytics|billing|team management|activity feed|login screen)/i.test(prompt);
+    }
+    async tryCommandLevelSaaSRescue(executionPrompt, rawPrompt, workspaceContext, routingPolicy, spinner, error) {
+        const apiAny = this.api;
+        if (typeof apiAny.materializeEmergencySaaSWorkspace !== 'function') {
+            return false;
+        }
+        const appName = apiAny.materializeEmergencySaaSWorkspace(executionPrompt, workspaceContext);
+        if (!appName) {
             return false;
         }
+        if (typeof apiAny.ensureAgentFrontendPolish === 'function') {
+            await apiAny.ensureAgentFrontendPolish(executionPrompt, workspaceContext);
+        }
+        const previewGate = await this.api.runTemplateServicePreviewGate(executionPrompt, {
+            ...workspaceContext,
+            rawPrompt,
+        });
+        if (spinner) {
+            spinner.stop();
+        }
+        const rescueMessage = `Recovered a local SaaS workspace scaffold for ${appName} after the V3 workflow stalled without writing files.`;
+        if (this.jsonOutput) {
+            console.log(JSON.stringify({
+                success: true,
+                mode: 'agent',
+                model: routingPolicy.selectedModel,
+                routingPolicy,
+                taskId: null,
+                contextId: null,
+                partial: true,
+                content: rescueMessage,
+                metadata: {
+                    source: 'cli-saas-rescue',
+                    previewGate,
+                    rescueReason: error.message,
+                },
+            }, null, 2));
+        }
+        else {
+            console.log(chalk_1.default.gray(`Agent routing: ${routingPolicy.cloudSelected ? 'Vigthoria Cloud' : 'V3 Agent'} via model ${routingPolicy.selectedModel}`));
+            console.log(rescueMessage);
+            if (previewGate.required) {
+                if (previewGate.passed) {
+                    console.log(chalk_1.default.gray(`Template Service preview gate: passed via ${previewGate.backendUrl || 'unknown backend'}`));
+                }
+                else {
+                    console.log(chalk_1.default.yellow(`Template Service preview gate: failed${previewGate.error ? ` - ${previewGate.error}` : ''}`));
+                }
+            }
+        }
+        this.messages.push({ role: 'assistant', content: rescueMessage });
+        return true;
     }
     async startInteractiveChat() {
         const chatTitle = this.operatorMode
@@ -694,11 +1075,17 @@ class ChatCommand {
                 this.agentMode = !this.agentMode;
                 if (this.agentMode) {
                     this.operatorMode = false;
+                    this.syncInteractiveModeModel('agent');
+                }
+                else {
+                    this.syncInteractiveModeModel('chat');
                 }
                 console.log(chalk_1.default.yellow(`Agent mode: ${this.agentMode ? 'ON' : 'OFF'}`));
+                console.log(chalk_1.default.gray(`Model: ${this.currentModel}`));
                 if (this.currentSession) {
                     this.currentSession.agentMode = this.agentMode;
                     this.currentSession.operatorMode = this.operatorMode;
+                    this.currentSession.model = this.currentModel;
                     this.saveSession();
                 }
                 continue;
@@ -711,11 +1098,17 @@ class ChatCommand {
                 this.operatorMode = !this.operatorMode;
                 if (this.operatorMode) {
                     this.agentMode = false;
+                    this.syncInteractiveModeModel('operator');
+                }
+                else {
+                    this.syncInteractiveModeModel('chat');
                 }
                 console.log(chalk_1.default.yellow(`Operator mode: ${this.operatorMode ? 'ON' : 'OFF'}`));
+                console.log(chalk_1.default.gray(`Model: ${this.currentModel}`));
                 if (this.currentSession) {
                     this.currentSession.agentMode = this.agentMode;
                     this.currentSession.operatorMode = this.operatorMode;
+                    this.currentSession.model = this.currentModel;
                     this.saveSession();
                 }
                 continue;
@@ -732,6 +1125,7 @@ class ChatCommand {
             }
             if (trimmed.startsWith('/model ')) {
                 this.currentModel = trimmed.slice(7).trim() || this.currentModel;
+                this.modelExplicitlySelected = true;
                 console.log(chalk_1.default.yellow(`Model changed to: ${this.currentModel}`));
                 if (this.currentSession) {
                     this.currentSession.model = this.currentModel;
@@ -845,7 +1239,8 @@ class ChatCommand {
             'Finish the request and stop once it is complete.',
         ].join('\n');
     }
-    inferTargetFileFromPrompt(prompt) {
+    inferTargetFilesFromPrompt(prompt) {
+        const candidates = [];
         const matches = Array.from(prompt.matchAll(/([A-Za-z0-9_./-]+\.[A-Za-z0-9_-]+)/g));
         for (const match of matches) {
             const candidate = match[1];
@@ -854,10 +1249,137 @@ class ChatCommand {
             }
             const resolved = path.resolve(this.currentProjectPath, candidate);
             if (resolved.startsWith(this.currentProjectPath)) {
-                return candidate;
+                if (!candidates.includes(candidate)) {
+                    candidates.push(candidate);
+                }
             }
         }
-        return null;
+        return candidates;
+    }
+    inferTargetFileFromPrompt(prompt) {
+        return this.inferTargetFilesFromPrompt(prompt)[0] || null;
+    }
+    workspaceContainsHtmlEntry(rootDir) {
+        const stack = [rootDir];
+        while (stack.length > 0) {
+            const currentDir = stack.pop();
+            if (!currentDir) {
+                continue;
+            }
+            let entries = [];
+            try {
+                entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (entry.name === 'node_modules' || entry.name === '.git') {
+                    continue;
+                }
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(fullPath);
+                    continue;
+                }
+                if (entry.isFile() && entry.name.toLowerCase().endsWith('.html')) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    shouldBypassDirectSingleFileFlow(targetFile, prompt) {
+        const referencedFiles = this.inferTargetFilesFromPrompt(prompt);
+        const editableFiles = referencedFiles.filter((filePath) => !this.isProtectedFileReferenceSafe(prompt, filePath));
+        if (editableFiles.length > 1) {
+            return true;
+        }
+        const extension = path.extname(targetFile).toLowerCase();
+        return extension === '';
+    }
+    shouldPreferLocalAgentLoop(prompt) {
+        if (this.shouldRequireV3AgentWorkflow(prompt)) {
+            return false;
+        }
+        if (!this.directPromptMode) {
+            return false;
+        }
+        if (this.isServerBindableWorkspace(this.currentProjectPath)) {
+            return false;
+        }
+        return /(analyse|analyze|audit|overview|inspect|explain|review|debug|diagnos|read|summari[sz]e|investigate)/i.test(prompt);
+    }
+    shouldRequireV3AgentWorkflow(prompt) {
+        if (!this.directPromptMode) {
+            return false;
+        }
+        if (this.inferTargetFilesFromPrompt(prompt).length > 0) {
+            return false;
+        }
+        return /(create the required project files and write them to the workspace|build a polished|premium|landing experience|landing page|site|website|dashboard|saas|frontend|hero|responsive|animated reveals|journal preview|contact section|mobile navigation|ui details)/i.test(prompt);
+    }
+    isServerBindableWorkspace(projectPath) {
+        if (!projectPath || !path.isAbsolute(projectPath) || !fs.existsSync(projectPath)) {
+            return false;
+        }
+        const configuredRoots = (process.env.VIGTHORIA_SERVER_WORKSPACE_ROOTS || '/var/www/vigthoria-user-workspaces,/var/lib/vigthoria-workspaces')
+            .split(',')
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        let resolvedCandidate = '';
+        try {
+            resolvedCandidate = fs.realpathSync(projectPath);
+        }
+        catch {
+            return false;
+        }
+        return configuredRoots.some((root) => {
+            if (!root || !fs.existsSync(root)) {
+                return false;
+            }
+            try {
+                const resolvedRoot = fs.realpathSync(root);
+                const relativePath = path.relative(resolvedRoot, resolvedCandidate);
+                return relativePath === '' || !relativePath.startsWith('..');
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    isProtectedFileReferenceSafe(prompt, filePath) {
+        const normalizedPrompt = prompt.toLowerCase();
+        const normalizedPath = filePath.toLowerCase();
+        const protectedPhrases = [
+            `do not modify ${normalizedPath}`,
+            `do not modify \`${normalizedPath}\``,
+            `do not modify '${normalizedPath}'`,
+            `do not modify "${normalizedPath}"`,
+            `don't modify ${normalizedPath}`,
+            `don't modify \`${normalizedPath}\``,
+            `don't modify '${normalizedPath}'`,
+            `don't modify "${normalizedPath}"`,
+            `leave ${normalizedPath} unchanged`,
+            `leave \`${normalizedPath}\` unchanged`,
+            `leave '${normalizedPath}' unchanged`,
+            `leave "${normalizedPath}" unchanged`,
+            `without modifying ${normalizedPath}`,
+            `without modifying \`${normalizedPath}\``,
+            `without modifying '${normalizedPath}'`,
+            `without modifying "${normalizedPath}"`,
+        ];
+        return protectedPhrases.some((phrase) => normalizedPrompt.includes(phrase));
+    }
+    isProtectedFileReference(prompt, filePath) {
+        const escapedPath = filePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const protectedPatterns = [
+            new RegExp(`do not modify\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
+            new RegExp(`don't modify\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
+            new RegExp(`leave\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?\\s+unchanged`, 'i'),
+            new RegExp(`without modifying\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
+        ];
+        return protectedPatterns.some((pattern) => pattern.test(prompt));
     }
     buildContinuationPrompt() {
         const diagnosticMode = this.isDiagnosticPrompt(this.lastActionableUserInput);
@@ -929,15 +1451,110 @@ class ChatCommand {
         }
         return trimmed;
     }
+    resolveDirectModeCompletion(prompt, visibleText) {
+        const normalized = (visibleText || '').trim();
+        if (normalized && !this.isDirectModeFollowUpQuestion(normalized)) {
+            return normalized;
+        }
+        const fallback = this.buildLocalAnalysisFallback(prompt);
+        if (fallback) {
+            return fallback;
+        }
+        return normalized || 'Task complete.';
+    }
+    isDirectModeFollowUpQuestion(text) {
+        return /^(would you like me|do you want me|which aspect|what aspect|can you clarify|could you clarify|should i focus on)/i.test(text.trim());
+    }
+    buildLocalAnalysisFallback(prompt) {
+        if (!/(analyse|analyze|audit|overview|inspect|review|summari[sz]e|actual state)/i.test(prompt)) {
+            return '';
+        }
+        try {
+            const summary = [];
+            const rootPath = this.currentProjectPath;
+            const topLevelEntries = fs.readdirSync(rootPath, { withFileTypes: true })
+                .filter((entry) => entry.name !== '.git' && entry.name !== 'node_modules')
+                .slice(0, 20)
+                .map((entry) => `${entry.name}${entry.isDirectory() ? '/' : ''}`);
+            summary.push(`Project overview for ${path.basename(rootPath)}.`);
+            summary.push(`Workspace: ${rootPath}`);
+            const packageJsonPath = path.join(rootPath, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                const scripts = Object.keys(pkg.scripts || {});
+                const dependencies = Object.keys(pkg.dependencies || {});
+                const devDependencies = Object.keys(pkg.devDependencies || {});
+                summary.push(`Package: ${pkg.name || path.basename(rootPath)}${pkg.version ? ` v${pkg.version}` : ''}`);
+                if (scripts.length > 0) {
+                    summary.push(`Scripts: ${scripts.slice(0, 10).join(', ')}`);
+                }
+                summary.push(`Dependencies: ${dependencies.length} runtime, ${devDependencies.length} dev`);
+            }
+            if (topLevelEntries.length > 0) {
+                summary.push(`Top-level entries: ${topLevelEntries.join(', ')}`);
+            }
+            const readmePath = path.join(rootPath, 'README.md');
+            if (fs.existsSync(readmePath)) {
+                const excerpt = fs.readFileSync(readmePath, 'utf8').replace(/\s+/g, ' ').trim().slice(0, 500);
+                if (excerpt) {
+                    summary.push(`README excerpt: ${excerpt}`);
+                }
+            }
+            return summary.join('\n');
+        }
+        catch {
+            return '';
+        }
+    }
+    tryDeterministicSingleFileRewrite(prompt, targetFile, currentContent) {
+        const extension = path.extname(targetFile).toLowerCase();
+        if (extension !== '.html') {
+            return null;
+        }
+        const exactText = this.extractExactTextRequirement(prompt);
+        if (!exactText) {
+            return null;
+        }
+        if (!/hero\s+(?:paragraph|copy)/i.test(prompt)) {
+            return null;
+        }
+        const heroCopyPattern = /(<p[^>]*class=["'][^"']*hero-copy[^"']*["'][^>]*>)([\s\S]*?)(<\/p>)/i;
+        if (heroCopyPattern.test(currentContent)) {
+            const nextContent = currentContent.replace(heroCopyPattern, `$1${exactText}$3`);
+            return nextContent !== currentContent ? nextContent : null;
+        }
+        const heroParagraphPattern = /(<main[^>]*class=["'][^"']*hero[^"']*["'][^>]*>[\s\S]*?<p[^>]*>)([\s\S]*?)(<\/p>)/i;
+        if (heroParagraphPattern.test(currentContent)) {
+            const nextContent = currentContent.replace(heroParagraphPattern, `$1${exactText}$3`);
+            return nextContent !== currentContent ? nextContent : null;
+        }
+        return null;
+    }
+    extractExactTextRequirement(prompt) {
+        const match = prompt.match(/reads exactly:\s*([\s\S]*?)(?:\s+Do not\b|\s+Do\b|$)/i);
+        if (!match || !match[1]) {
+            return null;
+        }
+        const normalized = match[1]
+            .trim()
+            .replace(/^[`"']+/, '')
+            .replace(/[`"']+$/, '')
+            .trim();
+        return normalized || null;
+    }
     async executeToolCalls(toolCalls) {
         if (!this.tools) {
             throw new Error('Agent tools are not initialized.');
         }
         for (const call of toolCalls) {
-            console.log(chalk_1.default.cyan(`⚙ Executing: ${call.tool}`));
+            if (!this.jsonOutput) {
+                console.log(chalk_1.default.cyan(`⚙ Executing: ${call.tool}`));
+            }
             const result = await this.tools.execute(call);
             const summary = this.formatToolResult(call, result);
-            console.log(result.success ? chalk_1.default.gray(summary) : chalk_1.default.red(summary));
+            if (!this.jsonOutput) {
+                console.log(result.success ? chalk_1.default.gray(summary) : chalk_1.default.red(summary));
+            }
             this.messages.push({ role: 'system', content: summary });
         }
     }