vigthoria-cli 1.6.8 → 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,7 +65,103 @@ 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();
+    }
+    operatorAccessMessage() {
+        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];
@@ -90,29 +187,105 @@ class ChatCommand {
     isDiagnosticPrompt(prompt) {
         return /(startup|start up|won'?t start|doesn'?t start|crash|crashes|error|errors|failing|fails|issue|issues|bug|bugs|diagnos|debug|runtime|log|logs|exception|traceback|stack trace|yaml|blocking|blocker)/i.test(prompt);
     }
+    isBrowserTaskPrompt(prompt) {
+        return /(browser|chrome|devtools|console|dom|network tab|network request|frontend runtime|client-side|client side|rendering|page load|websocket|ui bug|inspect element)/i.test(prompt);
+    }
     inferAgentTaskType(prompt) {
         return this.isDiagnosticPrompt(prompt) ? 'debugging' : 'implementation';
     }
     buildTaskShapingInstructions(prompt) {
-        if (!this.isDiagnosticPrompt(prompt)) {
+        const instructions = [];
+        if (this.isDiagnosticPrompt(prompt)) {
+            instructions.push('Diagnostic mode is active.', 'Treat this as a debugging task, not a generic code review or feature request.', 'Start with concrete evidence: logs, runtime errors, config, launch files, and exact symbol references.', 'If log files exist, inspect them before proposing fixes.', 'Do not claim a file, definition, asset, or symbol is missing until you verify that with tools.', 'If a prior diagnosis mentioned a missing symbol or YAML entry, re-check the actual files before repeating it.', 'Prefer grep plus read_file around the exact references involved in the failure.', 'Separate your reasoning into: Evidence, Confirmed Cause, and Remaining Hypotheses.', 'Do not suggest speculative fixes when the current evidence contradicts them.');
+        }
+        if (this.isBrowserTaskPrompt(prompt)) {
+            instructions.push('Browser-debug mode is active.', 'Prefer concrete browser evidence such as console errors, network failures, DOM state, and websocket behavior.', 'If a DevTools Bridge is available, use it as the primary browser observability path.');
+        }
+        if (instructions.length === 0) {
             return '';
         }
-        return [
-            'Diagnostic mode is active.',
-            'Treat this as a debugging task, not a generic code review or feature request.',
-            'Start with concrete evidence: logs, runtime errors, config, launch files, and exact symbol references.',
-            'If log files exist, inspect them before proposing fixes.',
-            'Do not claim a file, definition, asset, or symbol is missing until you verify that with tools.',
-            'If a prior diagnosis mentioned a missing symbol or YAML entry, re-check the actual files before repeating it.',
-            'Prefer grep plus read_file around the exact references involved in the failure.',
-            'Separate your reasoning into: Evidence, Confirmed Cause, and Remaining Hypotheses.',
-            'Do not suggest speculative fixes when the current evidence contradicts them.',
-        ].join('\n');
+        return instructions.join('\n');
     }
     buildExecutionPrompt(prompt) {
         const shaping = this.buildTaskShapingInstructions(prompt);
         return shaping ? `${prompt}\n\n${shaping}` : prompt;
     }
+    async getPromptRuntimeContext(prompt) {
+        if (!this.isBrowserTaskPrompt(prompt)) {
+            return {};
+        }
+        const bridgeStatus = await this.api.getDevtoolsBridgeStatus();
+        if (!this.jsonOutput && bridgeStatus.ok) {
+            console.log(chalk_1.default.gray(`Browser task detected. DevTools Bridge is reachable at ${bridgeStatus.endpoint}.`));
+        }
+        else if (!this.jsonOutput) {
+            console.log(chalk_1.default.yellow(`Browser task detected. DevTools Bridge is not running at ${bridgeStatus.endpoint}.`));
+        }
+        return {
+            browserTask: true,
+            devtoolsBridgeAvailable: bridgeStatus.ok,
+            devtoolsBridgeEndpoint: bridgeStatus.endpoint,
+        };
+    }
+    describeV3AgentTool(toolName) {
+        const normalized = String(toolName || '').toLowerCase();
+        if (/read|grep|search|list|find|glob/.test(normalized)) {
+            return 'Planning... gathering project context';
+        }
+        if (/write|edit|patch|create|delete|replace|rename/.test(normalized)) {
+            return 'Applying changes...';
+        }
+        if (/test|lint|build|run|exec|terminal/.test(normalized)) {
+            return 'Validating changes...';
+        }
+        return 'Working...';
+    }
+    updateV3AgentSpinner(spinner, event) {
+        if (!event || typeof event !== 'object') {
+            return;
+        }
+        if (event.type === 'tool_call') {
+            spinner.text = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
+            return;
+        }
+        if (event.type === 'message') {
+            spinner.text = 'Writing response...';
+            return;
+        }
+        if (event.type === 'complete') {
+            spinner.text = 'Finishing...';
+            return;
+        }
+        if (event.type === 'plan' || event.type === 'analysis' || event.type === 'thinking') {
+            spinner.text = 'Planning...';
+        }
+    }
+    updateOperatorSpinner(spinner, event) {
+        if (!event || typeof event !== 'object') {
+            return;
+        }
+        if (event.type === 'started') {
+            spinner.text = 'Starting BMAD workflow...';
+            return;
+        }
+        if (event.type === 'connected') {
+            spinner.text = 'Connected to BMAD stream...';
+            return;
+        }
+        if (event.type === 'agent') {
+            spinner.text = `Running ${event.agent || 'BMAD agent'}...`;
+            return;
+        }
+        if (event.type === 'status') {
+            const progress = Number.isFinite(Number(event.progress)) ? ` (${event.progress}%)` : '';
+            spinner.text = `${event.status || 'Working'}${progress}`;
+            return;
+        }
+        if (event.type === 'result') {
+            spinner.text = 'Finishing operator workflow...';
+            return;
+        }
+    }
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
@@ -125,14 +298,33 @@ class ChatCommand {
             return;
         }
         this.agentMode = options.agent === true;
-        this.autoApprove = options.autoApprove === true;
-        this.currentModel = options.model || 'code';
-        this.currentProjectPath = path.resolve(options.project || process.cwd());
+        this.operatorMode = options.operator === true;
+        this.workflowTarget = typeof options.workflow === 'string' && options.workflow.trim()
+            ? options.workflow.trim()
+            : null;
+        this.savePlanToVigFlow = options.savePlan === true;
+        this.jsonOutput = options.json === true;
+        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.');
+        }
         this.ensureProjectWorkspace();
         this.directPromptMode = Boolean(options.prompt);
         this.directToolContinuationCount = 0;
         this.tools = new tools_js_1.AgenticTools(this.logger, this.currentProjectPath, async (action) => this.requestPermission(action), this.autoApprove);
         this.initializeSession(options.resume === true);
+        if (this.operatorMode && !this.hasOperatorAccess()) {
+            if (this.currentSession) {
+                this.currentSession.operatorMode = false;
+                this.saveSession();
+            }
+            this.operatorMode = false;
+            this.logger.error(this.operatorAccessMessage());
+            return;
+        }
         if (options.prompt) {
             await this.handleDirectPrompt(options.prompt);
             return;
@@ -148,30 +340,270 @@ 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);
             if (this.currentSession) {
                 this.messages = [...this.currentSession.messages];
                 this.agentMode = this.currentSession.agentMode || this.agentMode;
+                this.operatorMode = this.currentSession.operatorMode || this.operatorMode;
                 this.currentModel = this.currentSession.model || this.currentModel;
                 return;
             }
         }
-        this.currentSession = this.sessionManager.create(this.currentProjectPath, this.currentModel, this.agentMode);
+        this.currentSession = this.sessionManager.create(this.currentProjectPath, this.currentModel, this.agentMode, this.operatorMode);
         this.messages = [...this.currentSession.messages];
     }
     async handleDirectPrompt(prompt) {
-        console.log(chalk_1.default.cyan('Running single prompt in direct mode.'));
-        console.log(chalk_1.default.gray(`Model: ${this.currentModel}`));
-        console.log(chalk_1.default.gray(`Project: ${this.currentProjectPath}`));
-        console.log();
+        if (!this.jsonOutput) {
+            console.log(chalk_1.default.cyan('Running single prompt in direct mode.'));
+            console.log(chalk_1.default.gray(`Model: ${this.currentModel}`));
+            console.log(chalk_1.default.gray(`Project: ${this.currentProjectPath}`));
+            if (this.workflowTarget) {
+                console.log(chalk_1.default.gray(`Workflow target: ${this.workflowTarget}`));
+            }
+            console.log();
+        }
+        if (this.workflowTarget) {
+            await this.runWorkflowTargetPrompt(prompt);
+            return;
+        }
         if (this.agentMode) {
             await this.runAgentTurn(prompt);
             return;
         }
+        if (this.operatorMode) {
+            if (!this.hasOperatorAccess()) {
+                this.logger.error(this.operatorAccessMessage());
+                return;
+            }
+            await this.runOperatorTurn(prompt);
+            return;
+        }
         await this.runSimplePrompt(prompt);
     }
+    formatWorkflowTargetResult(result) {
+        if (typeof result === 'string') {
+            return result.trim();
+        }
+        if (result == null) {
+            return '';
+        }
+        if (typeof result !== 'object') {
+            return String(result);
+        }
+        const entries = Object.entries(result)
+            .filter(([, value]) => typeof value === 'string' && String(value).trim());
+        if (entries.length === 1) {
+            return String(entries[0][1]).trim();
+        }
+        if (entries.length > 1) {
+            return entries
+                .map(([key, value]) => `${key}:\n${String(value).trim()}`)
+                .join('\n\n');
+        }
+        const serialized = JSON.stringify(result, null, 2);
+        return serialized === '{}' ? '' : serialized;
+    }
+    async runWorkflowTargetPrompt(prompt) {
+        const selector = this.workflowTarget;
+        if (!selector) {
+            throw new Error('Workflow target is not configured.');
+        }
+        this.lastActionableUserInput = prompt;
+        const executionPrompt = this.buildExecutionPrompt(prompt);
+        this.messages.push({ role: 'user', content: executionPrompt });
+        const runtimeContext = await this.getPromptRuntimeContext(prompt);
+        const resolvedWorkflow = await this.api.resolveVigFlowWorkflow(selector);
+        const invocationMode = this.operatorMode ? 'operator' : this.agentMode ? 'agent' : 'chat';
+        const spinner = this.jsonOutput ? null : (0, ora_1.default)({ text: `Running workflow ${resolvedWorkflow.name}...`, spinner: 'clock' }).start();
+        try {
+            const execution = await this.api.runVigFlowWorkflow(resolvedWorkflow.id, {
+                data: {
+                    request: executionPrompt,
+                    prompt: executionPrompt,
+                    rawPrompt: prompt,
+                    workspacePath: this.currentProjectPath,
+                    projectPath: this.currentProjectPath,
+                    targetPath: this.currentProjectPath,
+                    model: this.currentModel,
+                    history: this.getMessagesForModel(),
+                    executionSurface: invocationMode,
+                    clientSurface: 'cli',
+                    workflowTarget: {
+                        id: resolvedWorkflow.id,
+                        name: resolvedWorkflow.name,
+                        selector: resolvedWorkflow.selector,
+                        matchedBy: resolvedWorkflow.matchedBy,
+                    },
+                    ...runtimeContext,
+                },
+                executionOptions: {
+                    targetType: 'vigflow-workflow',
+                    targetSelector: resolvedWorkflow.selector,
+                    targetMatchedBy: resolvedWorkflow.matchedBy,
+                    executionSurface: invocationMode,
+                    clientSurface: 'cli',
+                    model: this.currentModel,
+                },
+            });
+            const content = this.formatWorkflowTargetResult(execution.result);
+            const assistantText = content || `Workflow ${resolvedWorkflow.name} completed with status ${execution.status}.`;
+            this.messages.push({ role: 'assistant', content: assistantText });
+            this.saveSession();
+            if (spinner) {
+                spinner.stop();
+            }
+            if (this.jsonOutput) {
+                console.log(JSON.stringify({
+                    success: true,
+                    workflow: resolvedWorkflow,
+                    mode: invocationMode,
+                    execution,
+                    content,
+                }, null, 2));
+                return;
+            }
+            this.logger.success(`Workflow target ${resolvedWorkflow.name} ${execution.status}`);
+            console.log(chalk_1.default.gray(`Workflow ID: ${resolvedWorkflow.id}`));
+            console.log(chalk_1.default.gray(`Execution ID: ${execution.executionId}`));
+            console.log(chalk_1.default.gray(`Mode: ${invocationMode}`));
+            if (content) {
+                console.log(content);
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail('Workflow target execution failed');
+            }
+            throw error;
+        }
+    }
+    async runOperatorTurn(prompt) {
+        if (!this.hasOperatorAccess()) {
+            this.logger.error(this.operatorAccessMessage());
+            return;
+        }
+        const runtimeContext = await this.getPromptRuntimeContext(prompt);
+        const spinner = this.jsonOutput ? null : (0, ora_1.default)({ text: 'Thinking like an operator...', spinner: 'clock' }).start();
+        const executionPrompt = this.buildExecutionPrompt(prompt);
+        const workflowType = this.isDiagnosticPrompt(prompt) ? 'analysis_only' : 'full_autonomy';
+        try {
+            const response = await this.api.runOperatorWorkflow(executionPrompt, {
+                workspacePath: this.currentProjectPath,
+                projectPath: this.currentProjectPath,
+                targetPath: this.currentProjectPath,
+                rawPrompt: prompt,
+                executionSurface: 'cli',
+                clientSurface: 'cli',
+                history: this.getMessagesForModel(),
+                workflowType,
+                model: this.currentModel,
+                savePlanToVigFlow: this.savePlanToVigFlow,
+                ...runtimeContext,
+                onStreamEvent: spinner ? (event) => this.updateOperatorSpinner(spinner, event) : undefined,
+            });
+            if (spinner) {
+                spinner.stop();
+            }
+            if (this.jsonOutput) {
+                console.log(JSON.stringify({
+                    success: true,
+                    mode: 'operator',
+                    workflowId: response.workflowId,
+                    savedWorkflow: response.savedWorkflow || null,
+                    contextId: response.contextId || null,
+                    content: response.content || 'Operator workflow completed.',
+                    metadata: response.metadata || {},
+                }, null, 2));
+            }
+            else {
+                console.log(response.content || 'Operator workflow completed.');
+                if (response.savedWorkflow?.id) {
+                    console.log(chalk_1.default.gray(`Saved VigFlow workflow: ${response.savedWorkflow.id}${response.savedWorkflow.name ? ` (${response.savedWorkflow.name})` : ''}`));
+                }
+            }
+            this.messages.push({ role: 'assistant', content: response.content || 'Operator workflow completed.' });
+            this.saveSession();
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail('Operator workflow failed');
+            }
+            this.logger.error(error.message);
+        }
+    }
     async runSimplePrompt(prompt) {
         this.lastActionableUserInput = prompt;
         this.messages.push({ role: 'user', content: this.buildExecutionPrompt(prompt) });
@@ -195,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;
         }
-        const handledByDirectFileFlow = await this.tryDirectSingleFileFlow(prompt);
-        if (handledByDirectFileFlow) {
+        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();
@@ -222,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;
                 }
@@ -236,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) {
@@ -251,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;
         }
@@ -296,54 +801,248 @@ 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 spinner = (0, ora_1.default)({ text: 'Running V3 agent workflow...', spinner: 'clock' }).start();
+        const runtimeContext = await this.getPromptRuntimeContext(prompt);
+        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,
             });
-            spinner.stop();
-            if (response.content) {
+            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 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.fail('V3 agent workflow rejected the result');
+                }
+                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,
+                    content: response.content || 'V3 agent workflow completed.',
+                    metadata: response.metadata || {},
+                }, 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) {
+                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: response.content || 'V3 agent workflow completed.' });
             return true;
         }
         catch (error) {
-            spinner.warn('Falling back to legacy CLI agent loop');
-            this.logger.debug(`V3 agent workflow unavailable: ${error.message}`);
+            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.fail('V3 agent workflow failed');
+            }
+            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() {
-        this.logger.section(this.agentMode ? 'Interactive Agent Chat' : 'Interactive Chat');
+        const chatTitle = this.operatorMode
+            ? 'Interactive Operator Chat'
+            : this.agentMode
+                ? 'Interactive Agent Chat'
+                : 'Interactive Chat';
+        this.logger.section(this.workflowTarget ? `${chatTitle} Via Workflow Target` : chatTitle);
         console.log(chalk_1.default.gray('Type /help for commands. Type /exit to quit.'));
+        if (this.workflowTarget) {
+            console.log(chalk_1.default.gray(`Workflow target: ${this.workflowTarget}`));
+        }
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
@@ -374,9 +1073,42 @@ class ChatCommand {
             }
             if (trimmed === '/agent') {
                 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;
+            }
+            if (trimmed === '/operator') {
+                if (!this.operatorMode && !this.hasOperatorAccess()) {
+                    this.logger.error(this.operatorAccessMessage());
+                    continue;
+                }
+                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;
@@ -393,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;
@@ -400,7 +1133,13 @@ class ChatCommand {
                 }
                 continue;
             }
-            if (this.agentMode) {
+            if (this.workflowTarget) {
+                await this.runWorkflowTargetPrompt(trimmed);
+            }
+            else if (this.operatorMode) {
+                await this.runOperatorTurn(trimmed);
+            }
+            else if (this.agentMode) {
                 await this.runAgentTurn(trimmed);
             }
             else {
@@ -414,6 +1153,7 @@ class ChatCommand {
         console.log('  /help   Show this help');
         console.log('  /exit   Exit chat');
         console.log('  /agent  Toggle agent mode');
+        console.log('  /operator  Toggle BMAD operator mode');
         console.log('  /context  Show current session memory');
         console.log('  /compact  Compact current session into memory summary');
         console.log('  /clear  Clear conversation');
@@ -499,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];
@@ -508,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);
@@ -583,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 });
         }
     }
@@ -617,11 +1580,12 @@ class ChatCommand {
     }
     saveSession() {
         if (!this.currentSession) {
-            this.currentSession = this.sessionManager.create(this.currentProjectPath, this.currentModel, this.agentMode);
+            this.currentSession = this.sessionManager.create(this.currentProjectPath, this.currentModel, this.agentMode, this.operatorMode);
         }
         this.currentSession.project = this.currentProjectPath;
         this.currentSession.model = this.currentModel;
         this.currentSession.agentMode = this.agentMode;
+        this.currentSession.operatorMode = this.operatorMode;
         this.currentSession.messages = [...this.messages];
         this.currentSession = this.sessionManager.compactInMemory(this.currentSession);
         this.messages = [...this.currentSession.messages];
@@ -658,4 +1622,3 @@ class ChatCommand {
     }
 }
 exports.ChatCommand = ChatCommand;
-//# sourceMappingURL=chat.js.map