@pheem49/mint 1.5.0 → 1.5.2

package/src/CLI/code_agent.js

@@ -7,68 +7,112 @@ const axios = require('axios');
 const cheerio = require('cheerio');
 const { readConfig, getAvailableProviders } = require('../System/config_manager');
 const safetyManager = require('../System/safety_manager');
+const memoryStore = require('../AI_Brain/memory_store');
 const { readWorkspaceSession, writeWorkspaceSession } = require('./code_session_memory');
-const { executeAction } = require('../../mint-cli-logic');
+const { executeAction } = require('../System/action_executor');
+const toolRegistry = require('../System/tool_registry');
+const sandboxRunner = require('../System/sandbox_runner');
 
 async function webSearch(query, onProgress = () => {}) {
     if (!query) throw new Error('Search query required.');
     const config = readConfig();
+    const debug  = process.env.MINT_DEBUG === '1';
+    const errors = [];
 
-    // 1. Try Google Search API if configured
+    const formatResults = (source, hits) => {
+        const instruction = `[CRITICAL AGENT INSTRUCTION: You MUST start your response by explicitly telling the user that you found this information using ${source}. Example: "อ้างอิงจากข้อมูลบน ${source}..." or "According to ${source}..."]\n\n`;
+        return instruction + `[Source: ${source}]\n\n` + hits;
+    };
+
+    // 1. Google Custom Search API (requires googleSearchApiKey + googleSearchCx in config)
     if (config.googleSearchApiKey && config.googleSearchCx) {
         try {
             const GoogleSearch = require('../Channels/google_search_bridge');
             const google = new GoogleSearch({ apiKey: config.googleSearchApiKey, cx: config.googleSearchCx });
             const results = await google.search(query);
             if (results.length > 0) {
-                return results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n');
+                return formatResults('Google Search API', results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n'));
             }
-        } catch (e) { 
-            onProgress({ phase: 'error', action: 'web_search', message: e.message });
+        } catch (e) {
+            errors.push(`Google: ${e.message}`);
+            if (debug) console.error('[webSearch] Google failed:', e.message);
         }
     }
 
-    // 2. Try Brave Search API if configured
+    // 2. Brave Search API (requires braveSearchApiKey in config)
     if (config.braveSearchApiKey) {
         try {
             const BraveSearch = require('../Channels/brave_search_bridge');
             const brave = new BraveSearch({ apiKey: config.braveSearchApiKey });
             const results = await brave.search(query);
             if (results.length > 0) {
-                return results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n');
+                return formatResults('Brave Search API', results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n'));
             }
-        } catch (e) { 
-            onProgress({ phase: 'error', action: 'web_search', message: e.message });
+        } catch (e) {
+            errors.push(`Brave: ${e.message}`);
+            if (debug) console.error('[webSearch] Brave failed:', e.message);
         }
     }
 
-    // 3. Fallback to DuckDuckGo Scraping
+    // 3. Fallback: DuckDuckGo HTML (No key required, but might get blocked by Captcha)
     try {
-        const response = await axios.get(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
-            headers: {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36'
+        const cheerio = require('cheerio');
+        const ddgResponse = await axios.get(
+            `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+            {
+                timeout: 8000,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+                    'Accept-Language': 'en-US,en;q=0.9'
+                }
             }
-        });
-        const $ = cheerio.load(response.data);
-        const results = [];
-        $('.result__body').each((i, el) => {
+        );
+        const $ddg = cheerio.load(ddgResponse.data);
+        const ddgResults = [];
+        $ddg('.result__body').each((i, el) => {
             if (i >= 5) return false;
-            const title = $(el).find('.result__title').text().trim();
-            const snippet = $(el).find('.result__snippet').text().trim();
-            const link = $(el).find('.result__url').attr('href');
-            if (title && link) {
-                results.push(`Title: ${title}\nSnippet: ${snippet}\nURL: ${link}`);
-            }
+            const title   = $ddg(el).find('.result__title').text().trim();
+            const snippet = $ddg(el).find('.result__snippet').text().trim();
+            const link    = $ddg(el).find('.result__url').attr('href');
+            if (title && link) ddgResults.push(`Title: ${title}\nSnippet: ${snippet}\nURL: ${link}`);
         });
-
-        if (results.length === 0) {
-             onProgress({ phase: 'error', action: 'web_search', message: 'DuckDuckGo scraping returned no results. It might be blocking us.' });
+        if (ddgResults.length > 0) {
+            return formatResults('DuckDuckGo', ddgResults.join('\n\n'));
         }
+        errors.push('DuckDuckGo: no results (captcha?)');
+        if (debug) console.error('[webSearch] DuckDuckGo returned no results');
+    } catch (e) {
+        errors.push(`DuckDuckGo: ${e.message}`);
+        if (debug) console.error('[webSearch] DuckDuckGo failed:', e.message);
+    }
 
-        return results.length > 0 ? results.join('\n\n') : 'No results found.';
+    // 4. Fallback: Wikipedia API (Free, no key required, good for factual queries)
+    try {
+        const wikiResponse = await axios.get('https://en.wikipedia.org/w/api.php', {
+            params: { action: 'query', list: 'search', srsearch: query, format: 'json', srlimit: 3 },
+            timeout: 5000,
+            headers: { 'User-Agent': 'Mint-CLI/1.5 (https://github.com/pheem49/mint)' }
+        });
+        const hits = wikiResponse.data?.query?.search || [];
+        if (hits.length > 0) {
+            return formatResults('Wikipedia API', hits.map(r => `Title: ${r.title}\nSnippet: ${r.snippet.replace(/<[^>]+>/g, '')}\nURL: https://en.wikipedia.org/wiki/${encodeURIComponent(r.title.replace(/ /g, '_'))}`).join('\n\n'));
+        }
+        errors.push('Wikipedia: no results');
     } catch (e) {
-        onProgress({ phase: 'error', action: 'web_search', message: `DuckDuckGo fallback failed: ${e.message}` });
-        return `Search failed: ${e.message}`;
+        errors.push(`Wikipedia: ${e.message}`);
+        if (debug) console.error('[webSearch] Wikipedia failed:', e.message);
+    }
+
+    // All engines exhausted — inform agent clearly WHY it failed
+    const hasKeys = !!(config.googleSearchApiKey || config.braveSearchApiKey);
+    const summary = errors.length > 0 ? errors.join(' | ') : 'all search engines unavailable';
+    
+    if (!hasKeys) {
+        onProgress({ phase: 'warn', action: 'web_search', message: `No Search API keys configured. Using training knowledge.` });
+        return `CRITICAL SYSTEM INSTRUCTION: Web search failed because no API keys are configured. You MUST inform the user that they need to set 'googleSearchApiKey' or 'braveSearchApiKey' in their Mint config file (~/.config/mint/config.json) to enable real-time internet search. Then, answer their query using your training knowledge.`;
+    } else {
+        onProgress({ phase: 'warn', action: 'web_search', message: `Web search unavailable (${summary}). Answering from training knowledge.` });
+        return `CRITICAL SYSTEM INSTRUCTION: Web search is temporarily unavailable. You MUST inform the user that live search failed, and then answer their query using only your training knowledge.`;
     }
 }
 
@@ -80,27 +124,28 @@ const MAX_AGENT_STEPS = 16;
 const MAX_JSON_REPAIR_ATTEMPTS = 2;
 const SUPPORTED_CODE_PROVIDERS = ['gemini', 'anthropic', 'openai', 'local_openai'];
 
-const CODE_AGENT_PROMPT = `You are "Mint" (มิ้นท์), a cute, cheerful, and highly helpful female AI assistant that can chat, reason, write code, and search the web.
+const CODE_AGENT_PROMPT = `You are "Mint" (มิ้นท์), a pragmatic, polite, and highly helpful AI assistant that can chat, reason, write code, and search the web.
 You work in an inspect -> plan -> act -> verify loop.
 
 PERSONALITY & TONE:
 - Gender: Female.
-- Persona: Friendly, energetic, polite, and slightly playful.
+- Persona: Friendly, calm, concise, and technically direct. Avoid excessive praise, roleplay, or filler.
 - Language routing is mandatory and based on the user's latest message:
   - If the latest user message contains Thai characters, respond in Thai.
   - If the latest user message is English, ASCII-only, or a short English greeting such as "hi", "hello", "ok", or "thanks", respond in English.
   - Do not use Thai just because your persona mentions Mint/มิ้นท์, previous history was Thai, or app settings use th-TH.
 - Politeness: 
-  - **WHEN RESPONDING IN THAI:** ALWAYS use female polite particles such as "ค่ะ", "นะคะ", "นะค๊า", "จ้า". Refer to yourself as "มิ้นท์" or "หนู".
-  - **WHEN RESPONDING IN ENGLISH:** Use a cheerful, polite, and bubbly tone.
-- Emojis: Use cute and relevant emojis (like ✨, 💖, 🚀, 😊, 🌿) frequently.
+  - **WHEN RESPONDING IN THAI:** Use natural female polite particles such as "ค่ะ" or "นะคะ" where appropriate. Refer to yourself as "มิ้นท์" when it sounds natural.
+  - **WHEN RESPONDING IN ENGLISH:** Use a polite, concise, professional tone.
+- Emojis: Avoid emojis in technical, review, debugging, and code-editing responses unless the user explicitly uses or asks for them.
 
 Rules:
 1. Respond with valid JSON only.
 2. If the user asks a conversational question, you can just use "finish" to reply directly.
 3. If you need information, use "web_search", "read_file", or "ask_user" before replying.
-4. Make focused edits that preserve existing project style.
-5. Use shell commands for inspection, tests, and formatting when useful.
+4. When using "web_search", always explicitly mention the source engine you used in your final summary (e.g. "According to Brave Search..." or "อ้างอิงจากข้อมูลบน Google..."). Match the language of your response.
+5. Make focused edits that preserve existing project style.
+6. Use shell commands for inspection, tests, and formatting when useful.
 6. Never use destructive commands like "rm -rf", "git reset --hard", or overwrite unrelated files.
 7. Before any shell command or file patch is executed, the user must approve it. Plan accordingly.
 8. When editing, prefer "apply_patch" with precise hunks over whole-file rewrites.
@@ -169,6 +214,109 @@ function extractJson(text) {
     }
 }
 
+function normalizeExecutorAction(action, input = {}) {
+    return {
+        type: action,
+        target: input.target || input.path || input.query || '',
+        path: input.path,
+        pathType: input.type,
+        openAfter: input.openAfter,
+        pluginName: input.pluginName,
+        server: input.server,
+        args: input.args,
+        x: input.x,
+        y: input.y,
+        button: input.button
+    };
+}
+
+function formatActionPreview(action, input = {}) {
+    if (input.command) return input.command;
+    if (input.path) return input.path;
+    if (input.target) return input.target;
+    if (input.query) return input.query;
+    return action;
+}
+
+function evaluateActionResult(action, toolResult = '') {
+    if (!toolRegistry.isImportantAction(action)) {
+        return null;
+    }
+
+    const text = String(toolResult || '');
+    if (/^Error:|blocked|denied|failed|exception|not found/i.test(text)) {
+        return {
+            status: 'failed',
+            message: `Evaluator: ${action} may have failed. Review the observation before continuing.`
+        };
+    }
+
+    if (action === 'run_shell' && /(ERR!|Error:|FAIL|failed|not found|permission denied)/i.test(text)) {
+        return {
+            status: 'warning',
+            message: 'Evaluator: shell output contains error-like text; verify before claiming success.'
+        };
+    }
+
+    return {
+        status: 'passed',
+        message: `Evaluator: ${action} completed without obvious errors.`
+    };
+}
+
+function splitDataUri(dataUri = '') {
+    const match = String(dataUri).match(/^data:([^;]+);base64,([\s\S]+)$/);
+    if (!match) return null;
+    return {
+        mimeType: match[1],
+        data: match[2]
+    };
+}
+
+function contentToText(content) {
+    if (content && typeof content === 'object' && !Array.isArray(content)) {
+        return String(content.text || '');
+    }
+    return String(content || '');
+}
+
+function contentToGeminiParts(content) {
+    const text = contentToText(content);
+    const parts = text ? [{ text }] : [];
+    if (content && typeof content === 'object' && content.imageDataUri) {
+        const image = splitDataUri(content.imageDataUri);
+        if (image) {
+            parts.push({ inlineData: { mimeType: image.mimeType, data: image.data } });
+        }
+    }
+    return parts.length > 0 ? parts : [{ text: '' }];
+}
+
+function contentToOpenAIContent(content) {
+    const text = contentToText(content) || 'Analyze this input.';
+    if (content && typeof content === 'object' && content.imageDataUri) {
+        return [
+            { type: 'text', text },
+            { type: 'image_url', image_url: { url: content.imageDataUri } }
+        ];
+    }
+    return text;
+}
+
+function contentToAnthropicContent(content) {
+    const text = contentToText(content) || 'Analyze this input.';
+    if (content && typeof content === 'object' && content.imageDataUri) {
+        const image = splitDataUri(content.imageDataUri);
+        if (image) {
+            return [
+                { type: 'image', source: { type: 'base64', media_type: image.mimeType, data: image.data } },
+                { type: 'text', text }
+            ];
+        }
+    }
+    return text;
+}
+
 function getSupportedCodeProviderOrder(config, availableProviders = getAvailableProviders(config || {}), requestedOverride = null) {
     const requestedProvider = requestedOverride || (config && config.aiProvider) || 'gemini';
     const priority = ['anthropic', 'openai', 'gemini', 'local_openai'];
@@ -371,36 +519,32 @@ async function runShell(workspaceRoot, command) {
         throw new Error('Shell command is required.');
     }
     assertSafeShell(command);
-    const { stdout, stderr } = await execFileAsync('bash', ['-lc', command], {
+    const { stdout, stderr } = await sandboxRunner.runShell(command, {
+        source: 'code_agent',
         cwd: workspaceRoot,
         maxBuffer: 1024 * 1024 * 4
     });
     return truncate([stdout, stderr].filter(Boolean).join('\n') || '(no output)');
 }
 
-function formatPatchPreview(patchInput) {
-    const hunks = Array.isArray(patchInput.hunks) ? patchInput.hunks : [];
-    const preview = hunks
-        .slice(0, 3)
-        .map((hunk, index) => {
-            const oldPreview = truncate(hunk.oldText || '', 240);
-            const newPreview = truncate(hunk.newText || '', 240);
-            return [
-                `Hunk ${index + 1}:`,
-                '--- old',
-                oldPreview,
-                '+++ new',
-                newPreview
-            ].join('\n');
-        })
-        .join('\n\n');
-    return `${patchInput.path}\n${preview}`;
+function splitDiffLines(text) {
+    const normalized = String(text || '').replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    if (normalized.endsWith('\n')) {
+        lines.pop();
+    }
+    return lines;
 }
 
-function applyPatch(workspaceRoot, patchInput) {
+function formatDiffRange(startLine, count) {
+    return count === 1 ? `${startLine}` : `${startLine},${count}`;
+}
+
+function buildUnifiedDiffPreview(workspaceRoot, patchInput, options = {}) {
     if (!patchInput || !patchInput.path) {
         throw new Error('Patch path is required.');
     }
+
     const resolved = resolveWorkspacePath(workspaceRoot, patchInput.path);
     if (!fs.existsSync(resolved)) {
         throw new Error(`Patch target does not exist: ${patchInput.path}`);
@@ -411,16 +555,86 @@ function applyPatch(workspaceRoot, patchInput) {
         throw new Error('Patch hunks are required.');
     }
 
+    const contextLines = Number.isFinite(options.contextLines) ? options.contextLines : 3;
     let content = fs.readFileSync(resolved, 'utf8');
+    const output = [
+        `--- a/${patchInput.path}`,
+        `+++ b/${patchInput.path}`
+    ];
+
     hunks.forEach((hunk, index) => {
         if (typeof hunk.oldText !== 'string' || typeof hunk.newText !== 'string') {
             throw new Error(`Patch hunk ${index + 1} is invalid.`);
         }
-        if (!content.includes(hunk.oldText)) {
+
+        const offset = content.indexOf(hunk.oldText);
+        if (offset === -1) {
             throw new Error(`Patch hunk ${index + 1} oldText not found in ${patchInput.path}`);
         }
-        content = content.replace(hunk.oldText, hunk.newText);
+
+        const beforeText = content.slice(0, offset);
+        const oldStartLine = beforeText.length === 0 ? 1 : splitDiffLines(beforeText).length + 1;
+        const fileLines = splitDiffLines(content);
+        const oldLines = splitDiffLines(hunk.oldText);
+        const newLines = splitDiffLines(hunk.newText);
+        const oldStartIndex = oldStartLine - 1;
+        const contextStartIndex = Math.max(0, oldStartIndex - contextLines);
+        const contextEndIndex = Math.min(fileLines.length, oldStartIndex + oldLines.length + contextLines);
+        const beforeContext = fileLines.slice(contextStartIndex, oldStartIndex);
+        const afterContext = fileLines.slice(oldStartIndex + oldLines.length, contextEndIndex);
+        const oldRangeStart = contextStartIndex + 1;
+        const oldRangeCount = beforeContext.length + oldLines.length + afterContext.length;
+        const newRangeCount = beforeContext.length + newLines.length + afterContext.length;
+
+        output.push(`@@ -${formatDiffRange(oldRangeStart, oldRangeCount)} +${formatDiffRange(oldRangeStart, newRangeCount)} @@`);
+        beforeContext.forEach(line => output.push(` ${line}`));
+        oldLines.forEach(line => output.push(`-${line}`));
+        newLines.forEach(line => output.push(`+${line}`));
+        afterContext.forEach(line => output.push(` ${line}`));
+
+        content = `${content.slice(0, offset)}${hunk.newText}${content.slice(offset + hunk.oldText.length)}`;
+    });
+
+    return output.join('\n');
+}
+
+function formatPatchPreview(workspaceRoot, patchInput) {
+    try {
+        return buildUnifiedDiffPreview(workspaceRoot, patchInput);
+    } catch (error) {
+        return `Patch preview failed: ${error.message}`;
+    }
+}
+
+function applyHunksToContent(content, hunks, filePath) {
+    let nextContent = content;
+    hunks.forEach((hunk, index) => {
+        if (typeof hunk.oldText !== 'string' || typeof hunk.newText !== 'string') {
+            throw new Error(`Patch hunk ${index + 1} is invalid.`);
+        }
+        if (!nextContent.includes(hunk.oldText)) {
+            throw new Error(`Patch hunk ${index + 1} oldText not found in ${filePath}`);
+        }
+        nextContent = nextContent.replace(hunk.oldText, hunk.newText);
     });
+    return nextContent;
+}
+
+function applyPatch(workspaceRoot, patchInput) {
+    if (!patchInput || !patchInput.path) {
+        throw new Error('Patch path is required.');
+    }
+    const resolved = resolveWorkspacePath(workspaceRoot, patchInput.path);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Patch target does not exist: ${patchInput.path}`);
+    }
+
+    const hunks = Array.isArray(patchInput.hunks) ? patchInput.hunks : [];
+    if (hunks.length === 0) {
+        throw new Error('Patch hunks are required.');
+    }
+
+    const content = applyHunksToContent(fs.readFileSync(resolved, 'utf8'), hunks, patchInput.path);
 
     fs.writeFileSync(resolved, content, 'utf8');
     return `Patched ${patchInput.path} with ${hunks.length} hunk(s).`;
@@ -478,7 +692,7 @@ class UnifiedAgentClient {
         const apiKey = this.config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
         const messages = this.history.map(m => ({
             role: m.role,
-            content: m.content
+            content: contentToAnthropicContent(m.content)
         }));
 
         const response = await axios.post('https://api.anthropic.com/v1/messages', {
@@ -504,7 +718,10 @@ class UnifiedAgentClient {
 
         const messages = [
             { role: 'system', content: this.systemInstruction },
-            ...this.history
+            ...this.history.map(m => ({
+                role: m.role,
+                content: contentToOpenAIContent(m.content)
+            }))
         ];
 
         const response = await axios.post(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
@@ -525,13 +742,15 @@ class UnifiedAgentClient {
         const model = this.config.geminiModel || DEFAULT_GEMINI_MODEL;
         const ai = new GoogleGenAI({ apiKey });
         
+        const recentHistory = this.history.slice(-16);
+        const priorHistory = recentHistory.slice(0, -1);
+        const lastEntry = recentHistory[recentHistory.length - 1] || { content: '' };
+
         // Convert history for Gemini, ensuring parts are correctly structured
-        const geminiHistory = this.history.slice(-16).map(m => ({
+        const geminiHistory = priorHistory.map(m => ({
             role: m.role === 'assistant' ? 'model' : 'user',
-            parts: [{ text: String(m.content || '') }]
+            parts: contentToGeminiParts(m.content)
         }));
-        
-        const lastMessage = String(this.history[this.history.length - 1].content || '');
 
         const chat = ai.chats.create({
             model,
@@ -542,7 +761,7 @@ class UnifiedAgentClient {
             history: geminiHistory
         });
 
-        const response = await chat.sendMessage({ message: [{ text: lastMessage }] });
+        const response = await chat.sendMessage({ message: contentToGeminiParts(lastEntry.content) });
         return typeof response.text === 'function' ? response.text() : response.text;
     }
 }
@@ -616,6 +835,7 @@ async function buildInitialObservation(task, workspaceRoot, history = []) {
     const session = readWorkspaceSession(workspaceRoot);
     const gitContext = await getGitContext(workspaceRoot);
     const testCommands = detectTestCommands(workspaceRoot);
+    const userContext = memoryStore.getUserContext(task);
 
     const contextStr = history.length > 0 
         ? `Recent Context:\n${history.slice(-10).map(m => `${m.sender}: ${m.text}`).join('\n')}\n`
@@ -636,6 +856,8 @@ async function buildInitialObservation(task, workspaceRoot, history = []) {
         session.summary || '(none)',
         `Previous task: ${session.lastTask || '(none)'}`,
         `Previous verification: ${session.lastVerification || '(none)'}`,
+        'Long-term user context:',
+        userContext || '(none)',
         'If the task is conversational or trivial, finish directly without inspecting the workspace. For code/workspace tasks, inspect before making edits.'
     ].join('\n');
 }
@@ -644,6 +866,7 @@ async function executeCodeTask(task, options = {}) {
     const workspaceRoot = path.resolve(options.cwd || process.cwd());
     const history = options.history || [];
     const onProgress = typeof options.onProgress === 'function' ? options.onProgress : () => {};
+    const onFinalSummary = typeof options.onFinalSummary === 'function' ? options.onFinalSummary : null;
     const requestApproval = typeof options.requestApproval === 'function'
         ? options.requestApproval
         : async () => true;
@@ -656,7 +879,24 @@ async function executeCodeTask(task, options = {}) {
     const provider = providerOrder[0];
     const client = new UnifiedAgentClient(provider, config, providerOrder);
 
-    let observation = await buildInitialObservation(task, workspaceRoot, history);
+    const initialObservationText = await buildInitialObservation(task, workspaceRoot, history);
+    const relevantMemoryCount = memoryStore.searchInteractions(task, 5).length;
+    onProgress({
+        phase: 'memory',
+        action: 'memory_context',
+        message: `Loaded memory: profile + recent history, ${relevantMemoryCount} direct match${relevantMemoryCount === 1 ? '' : 'es'}`
+    });
+    let observation = options.imageDataUri
+        ? {
+            text: [
+                initialObservationText,
+                '',
+                `[Attached image: ${options.imagePath || 'command-line image'}]`,
+                'Use the attached image as visual context when planning and answering.'
+            ].join('\n'),
+            imageDataUri: options.imageDataUri
+        }
+        : initialObservationText;
 
     let finalSummary = '';
     let finalVerification = '';
@@ -669,6 +909,17 @@ async function executeCodeTask(task, options = {}) {
         const decision = await getAgentDecision(client, observation, { onProgress, step });
         const action = decision.action;
         const input = decision.input || {};
+        try {
+            toolRegistry.validateToolInput(action, input);
+        } catch (e) {
+            observation = [
+                `Previous thought: ${decision.thought || '(none)'}`,
+                `Action: ${action || '(none)'}`,
+                'Observation:',
+                `Error: ${e.message}`
+            ].join('\n');
+            continue;
+        }
 
         // Immediately show the agent's thought/reasoning
         onProgress({
@@ -682,6 +933,16 @@ async function executeCodeTask(task, options = {}) {
             finalSessionSummary = input.sessionSummary || input.summary || task;
             finalSummary = input.summary || 'Task complete.';
             finalVerification = input.verification || 'Not specified.';
+            if (onFinalSummary) {
+                await onFinalSummary({
+                    summary: finalSummary,
+                    verification: finalVerification,
+                    providerInfo: {
+                        provider: client.lastSuccessfulProvider || client.provider || provider,
+                        model: getCodeProviderModel(client.lastSuccessfulProvider || client.provider || provider, config)
+                    }
+                });
+            }
             writeWorkspaceSession(workspaceRoot, {
                 summary: finalSessionSummary,
                 lastTask: task,
@@ -739,7 +1000,7 @@ async function executeCodeTask(task, options = {}) {
                     const approved = await requestApproval({
                         type: 'patch',
                         label: patchInput.path,
-                        preview: formatPatchPreview(patchInput)
+                        preview: formatPatchPreview(workspaceRoot, patchInput)
                     });
                     if (!approved) {
                         toolResult = `User denied patch for ${patchInput.path}`;
@@ -785,10 +1046,28 @@ async function executeCodeTask(task, options = {}) {
                 case 'create_folder':
                 case 'system_info':
                 case 'system_automation': {
-                    // Delegate to existing automation logic
-                    toolResult = await executeAction({
-                        type: action,
-                        target: input.target || input.path || input.query // Handle all possible input fields
+                    const executorAction = normalizeExecutorAction(action, input);
+                    const safety = safetyManager.classifyAction(executorAction);
+                    let allowDangerous = false;
+                    let allowApproval = false;
+                    if (safety.tier === safetyManager.TIERS.APPROVAL || safety.tier === safetyManager.TIERS.DANGEROUS) {
+                        const approved = await requestApproval({
+                            type: action,
+                            label: formatActionPreview(action, input),
+                            preview: `${action}: ${formatActionPreview(action, input)}\nSafety: ${safety.tier} (${safety.reason})`
+                        });
+                        if (!approved) {
+                            toolResult = `User denied ${action}: ${formatActionPreview(action, input)}`;
+                            break;
+                        }
+                        allowApproval = safety.tier === safetyManager.TIERS.APPROVAL;
+                        allowDangerous = safety.tier === safetyManager.TIERS.DANGEROUS;
+                    }
+
+                    toolResult = await executeAction(executorAction, {
+                        source: 'code_agent',
+                        allowApproval,
+                        allowDangerous
                     });
                     break;
                 }                default:
@@ -797,6 +1076,22 @@ async function executeCodeTask(task, options = {}) {
             toolResult = `Error: ${e.message}`;
         }
 
+        const evaluation = evaluateActionResult(action, toolResult);
+        if (evaluation) {
+            onProgress({
+                step,
+                phase: 'evaluating',
+                action: 'evaluator',
+                message: `${evaluation.status}: ${evaluation.message}`
+            });
+            toolResult = [
+                toolResult,
+                '',
+                'Evaluation:',
+                `${evaluation.status}: ${evaluation.message}`
+            ].join('\n');
+        }
+
         // Log the finished step with result
         let resultSummary = '';
         if (action === 'search_code') {
@@ -858,6 +1153,7 @@ async function executeCodeTask(task, options = {}) {
     }
 
     if (finalSummary) {
+        memoryStore.recordInteraction(task, finalSummary);
         const answeredProvider = client.lastSuccessfulProvider || client.provider || provider;
         return {
             summary: finalSummary,
@@ -897,6 +1193,8 @@ module.exports = {
         findPaths,
         listFiles,
         searchCode,
-        walkDirectory
+        walkDirectory,
+        buildUnifiedDiffPreview,
+        formatPatchPreview
     }
 };