vigthoria-cli 1.6.5 → 1.6.9

package/dist/commands/chat.js

@@ -39,11 +39,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 const api_js_1 = require("../utils/api.js");
 const tools_js_1 = require("../utils/tools.js");
 const session_js_1 = require("../utils/session.js");
+const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
+    const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS || '1200000';
+    const parsed = Number.parseInt(rawValue, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1200000;
+})();
 class ChatCommand {
     config;
     logger;
@@ -59,6 +65,141 @@ class ChatCommand {
     directToolContinuationCount = 0;
     currentModel = 'code';
     autoApprove = false;
+    operatorMode = false;
+    workflowTarget = null;
+    savePlanToVigFlow = false;
+    jsonOutput = false;
+    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}.`;
+    }
+    getMessagesForModel() {
+        const memoryContext = this.sessionManager.buildMemoryContext(this.currentSession);
+        const messages = [...this.messages];
+        if (!memoryContext) {
+            return messages;
+        }
+        const alreadyInjected = messages.some((message) => message.role === 'system' && message.content.includes('Session memory summary from earlier conversation turns.'));
+        if (alreadyInjected) {
+            return messages;
+        }
+        const insertionIndex = messages.findIndex((message) => message.role !== 'system');
+        const memoryMessage = {
+            role: 'system',
+            content: memoryContext,
+        };
+        if (insertionIndex === -1) {
+            messages.push(memoryMessage);
+            return messages;
+        }
+        messages.splice(insertionIndex, 0, memoryMessage);
+        return messages;
+    }
+    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) {
+        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 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;
@@ -71,49 +212,246 @@ class ChatCommand {
             return;
         }
         this.agentMode = options.agent === true;
+        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.currentModel = options.model || 'code';
         this.currentProjectPath = path.resolve(options.project || process.cwd());
+        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;
         }
         await this.startInteractiveChat();
     }
+    ensureProjectWorkspace() {
+        if (fs.existsSync(this.currentProjectPath)) {
+            if (!fs.statSync(this.currentProjectPath).isDirectory()) {
+                throw new Error(`Project path is not a directory: ${this.currentProjectPath}`);
+            }
+            return;
+        }
+        fs.mkdirSync(this.currentProjectPath, { recursive: true });
+    }
     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: prompt });
+        this.messages.push({ role: 'user', content: this.buildExecutionPrompt(prompt) });
         const spinner = (0, ora_1.default)({ text: 'Thinking...', spinner: 'clock' }).start();
         try {
-            const response = await this.api.chat(this.messages, this.currentModel);
+            const response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
             spinner.stop();
             const finalText = response.message.trim();
             if (finalText) {
@@ -136,6 +474,11 @@ class ChatCommand {
             this.saveSession();
             return;
         }
+        const handledByV3Workflow = await this.tryV3AgentWorkflow(prompt);
+        if (handledByV3Workflow) {
+            this.saveSession();
+            return;
+        }
         this.lastActionableUserInput = prompt;
         this.directToolContinuationCount = 0;
         this.tools.clearSessionApprovals();
@@ -146,7 +489,7 @@ class ChatCommand {
         for (let turn = 0; turn < maxTurns; turn += 1) {
             const spinner = (0, ora_1.default)({ text: turn === 0 ? 'Planning...' : 'Continuing...', spinner: 'clock' }).start();
             try {
-                const response = await this.api.chat(this.messages, this.currentModel);
+                const response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
                 spinner.stop();
                 const assistantMessage = response.message || '';
                 this.messages.push({ role: 'assistant', content: assistantMessage });
@@ -238,9 +581,87 @@ class ChatCommand {
         console.log(`Updated ${targetFile}.`);
         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 executionPrompt = this.buildExecutionPrompt(prompt);
+        const agentTaskType = this.inferAgentTaskType(prompt);
+        try {
+            const response = await this.api.runV3AgentWorkflow(executionPrompt, {
+                workspace: { path: this.currentProjectPath },
+                workspacePath: this.currentProjectPath,
+                projectPath: this.currentProjectPath,
+                targetPath: this.currentProjectPath,
+                agentTaskType,
+                executionSurface: 'cli',
+                clientSurface: 'cli',
+                localMachineCapable: true,
+                agentTimeoutMs: DEFAULT_V3_AGENT_TIMEOUT_MS,
+                agentIdleTimeoutMs: 90000,
+                rawPrompt: prompt,
+                history: this.getMessagesForModel(),
+                ...runtimeContext,
+                onStreamEvent: spinner ? (event) => this.updateV3AgentSpinner(spinner, event) : undefined,
+            });
+            if (spinner) {
+                spinner.stop();
+            }
+            const previewGate = (response.metadata?.previewGate || null);
+            const success = previewGate?.required === true ? previewGate?.passed === true : true;
+            if (!success) {
+                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;
+            }
+            if (this.jsonOutput) {
+                console.log(JSON.stringify({
+                    success,
+                    mode: 'agent',
+                    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(response.content);
+            }
+            else {
+                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) {
+            if (spinner) {
+                spinner.warn('Falling back to legacy CLI agent loop');
+            }
+            this.logger.debug(`V3 agent workflow unavailable: ${error.message}`);
+            return false;
+        }
+    }
     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,
@@ -261,11 +682,40 @@ class ChatCommand {
                 this.showHelp();
                 continue;
             }
+            if (trimmed === '/context') {
+                this.showContext();
+                continue;
+            }
+            if (trimmed === '/compact') {
+                this.compactCurrentSession();
+                continue;
+            }
             if (trimmed === '/agent') {
                 this.agentMode = !this.agentMode;
+                if (this.agentMode) {
+                    this.operatorMode = false;
+                }
                 console.log(chalk_1.default.yellow(`Agent mode: ${this.agentMode ? 'ON' : 'OFF'}`));
                 if (this.currentSession) {
                     this.currentSession.agentMode = this.agentMode;
+                    this.currentSession.operatorMode = this.operatorMode;
+                    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;
+                }
+                console.log(chalk_1.default.yellow(`Operator mode: ${this.operatorMode ? 'ON' : 'OFF'}`));
+                if (this.currentSession) {
+                    this.currentSession.agentMode = this.agentMode;
+                    this.currentSession.operatorMode = this.operatorMode;
                     this.saveSession();
                 }
                 continue;
@@ -289,7 +739,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 {
@@ -303,11 +759,40 @@ 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');
         console.log('  /save   Save session');
         console.log('  /model <name>  Change model');
         console.log('');
     }
+    showContext() {
+        if (!this.currentSession) {
+            console.log(chalk_1.default.yellow('No active session.'));
+            return;
+        }
+        console.log(chalk_1.default.cyan(this.getCurrentSessionInfo()));
+        if (this.currentSession.memorySummary?.trim()) {
+            console.log();
+            console.log(chalk_1.default.white('Compact Memory:'));
+            console.log(chalk_1.default.gray(this.currentSession.memorySummary.trim()));
+        }
+        else {
+            console.log(chalk_1.default.gray('No compact memory summary yet.'));
+        }
+    }
+    compactCurrentSession() {
+        if (!this.currentSession) {
+            console.log(chalk_1.default.yellow('No active session.'));
+            return;
+        }
+        this.currentSession.messages = [...this.messages];
+        this.currentSession = this.sessionManager.compactInMemory(this.currentSession);
+        this.messages = [...this.currentSession.messages];
+        this.sessionManager.save(this.currentSession);
+        console.log(chalk_1.default.green('Session compacted into memory summary.'));
+    }
     ensureAgentSystemPrompt() {
         const hasSystemPrompt = this.messages.some((message) => message.role === 'system' && message.content.includes('Vigthoria CLI agent operating contract'));
         if (hasSystemPrompt) {
@@ -333,6 +818,10 @@ class ChatCommand {
             'Stay inside that project unless the user explicitly asks otherwise.',
             'Read files before editing or rewriting them.',
             'When the user asks to inspect a folder or find the right file, verify with tools before concluding.',
+            'For debugging or startup issues, inspect logs and concrete runtime evidence before proposing fixes.',
+            'Do not claim a file, asset, symbol, YAML entry, or definition is missing until you verify it with tools.',
+            'If earlier output claimed something is missing, re-check the exact file and symbol before repeating that claim.',
+            'When diagnosing failures, prefer evidence-backed conclusions over broad repo scans.',
             'If the user corrects you, treat that as evidence that your previous assumption was wrong and re-check with tools.',
             'Do not stop after a partial answer when more direct inspection is possible.',
             'When you need a tool, emit only one or more tool wrappers in this exact format:',
@@ -349,7 +838,7 @@ class ChatCommand {
     }
     buildScopedUserPrompt(prompt) {
         return [
-            prompt,
+            this.buildExecutionPrompt(prompt),
             '',
             `Project root: ${this.currentProjectPath}`,
             'Stay within this project root unless the user explicitly expands scope.',
@@ -371,12 +860,14 @@ class ChatCommand {
         return null;
     }
     buildContinuationPrompt() {
+        const diagnosticMode = this.isDiagnosticPrompt(this.lastActionableUserInput);
         return [
             `Tool results received for direct mode step ${this.directToolContinuationCount + 1}.`,
             `Original user request: ${this.lastActionableUserInput}`,
             `Project root boundary: ${this.currentProjectPath}`,
             'Do not declare success until the exact user question has been answered with tool-backed evidence.',
             'If a user is asking which file is correct or most recent, keep inspecting until you can justify the answer from actual results.',
+            diagnosticMode ? 'Because this is a debugging task, prefer logs, runtime evidence, and exact symbol references over generic fixes.' : 'Keep working from concrete tool results.',
             'If the request is already satisfied, return a concise completion summary and no tool calls.',
             'If more work is required, continue with only the next minimal tool calls needed to finish it.',
             'Do not ask follow-up questions or drift into unrelated tasks.',
@@ -472,12 +963,15 @@ 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];
         this.sessionManager.save(this.currentSession);
     }
     async requestPermission(action) {
@@ -503,11 +997,11 @@ class ChatCommand {
         if (!this.currentSession) {
             return 'No active session';
         }
-        return `Session: ${this.currentSession.name} (${this.currentSession.messages.length} messages)`;
+        const compacted = this.currentSession.memorySummary ? ' with compact memory' : '';
+        return `Session: ${this.currentSession.name} (${this.currentSession.messages.length} messages${compacted})`;
     }
     getChatHistory() {
         return [...this.messages];
     }
 }
 exports.ChatCommand = ChatCommand;
-//# sourceMappingURL=chat.js.map