@pheem49/mint 1.5.0 → 1.5.2

package/src/AI_Brain/memory_store.js

@@ -93,17 +93,49 @@ function getDb() {
             last_used DATETIME DEFAULT CURRENT_TIMESTAMP
         );
 
+        -- Raw episodic memories of user/assistant turns.
+        CREATE TABLE IF NOT EXISTS interaction_memories (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_text   TEXT NOT NULL,
+            ai_text     TEXT NOT NULL,
+            keywords    TEXT DEFAULT '',
+            created_at  DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+
         -- Response Cache: For repetitive exact queries
         CREATE TABLE IF NOT EXISTS response_cache (
             query_hash TEXT PRIMARY KEY,
             response   TEXT NOT NULL,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP
         );
+
+        -- Learned skill/instruction documents imported from local files.
+        CREATE TABLE IF NOT EXISTS learned_skills (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            name       TEXT NOT NULL,
+            source_path TEXT NOT NULL UNIQUE,
+            content    TEXT NOT NULL,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
     `);
 
     return dbInstance;
 }
 
+function ensureLearnedSkillsTable() {
+    getDb().exec(`
+        CREATE TABLE IF NOT EXISTS learned_skills (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            name        TEXT NOT NULL,
+            source_path TEXT NOT NULL UNIQUE,
+            content     TEXT NOT NULL,
+            created_at  DATETIME DEFAULT CURRENT_TIMESTAMP,
+            updated_at  DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+    `);
+}
+
 // ── Profile helpers ────────────────────────────────────────────────────────
 function setProfile(key, value) {
     try {
@@ -203,6 +235,116 @@ function getTopPatterns(limit = 8) {
     }
 }
 
+const MAX_INTERACTION_MEMORIES = 1000;
+
+function stripRelevantMemoryBlock(text) {
+    return String(text || '')
+        .replace(/\n?\[Relevant long-term memory for this user message\][\s\S]*?\[End relevant memory\]\n?/g, '\n')
+        .replace(/^\s*\[Relevant long-term memory for this user message\][\s\S]*?\[End relevant memory\]\s*/g, '')
+        .replace(/\n?\[LOCAL KNOWLEDGE BASE - USE THIS CONTEXT TO ANSWER\][\s\S]*/g, '')
+        .trim();
+}
+
+function addInteractionMemory(userMessage, aiResponseText, keywords = []) {
+    try {
+        const db = getDb();
+        db.prepare(`
+            INSERT INTO interaction_memories (user_text, ai_text, keywords)
+            VALUES (?, ?, ?)
+        `).run(
+            String(userMessage || '').slice(0, 1200),
+            String(aiResponseText || '').slice(0, 1200),
+            keywords.join(',')
+        );
+        db.exec(`
+            DELETE FROM interaction_memories WHERE id NOT IN (
+                SELECT id FROM interaction_memories ORDER BY id DESC LIMIT ${MAX_INTERACTION_MEMORIES}
+            )
+        `);
+    } catch (err) {
+        console.error('[Memory] addInteractionMemory error:', err.message);
+    }
+}
+
+function getRecentInteractions(limit = 5) {
+    try {
+        return getDb()
+            .prepare('SELECT id, user_text, ai_text, keywords, created_at FROM interaction_memories ORDER BY id DESC LIMIT ?')
+            .all(limit);
+    } catch (_) {
+        return [];
+    }
+}
+
+function deleteInteractionMemory(id) {
+    try {
+        const result = getDb().prepare('DELETE FROM interaction_memories WHERE id = ?').run(id);
+        return result.changes > 0;
+    } catch (err) {
+        console.error('[Memory] deleteInteractionMemory error:', err.message);
+        return false;
+    }
+}
+
+function searchInteractions(query, limit = 8) {
+    try {
+        const keywords = extractKeywords(query);
+        const terms = keywords.length > 0 ? keywords : [String(query || '').trim()].filter(Boolean);
+        if (terms.length === 0) return [];
+
+        const rows = [];
+        const seen = new Set();
+        const stmt = getDb().prepare(`
+            SELECT id, user_text, ai_text, keywords, created_at
+            FROM interaction_memories
+            WHERE user_text LIKE ? OR ai_text LIKE ? OR keywords LIKE ?
+            ORDER BY id DESC
+            LIMIT ?
+        `);
+
+        for (const term of terms.slice(0, 5)) {
+            const like = `%${term}%`;
+            for (const row of stmt.all(like, like, like, limit)) {
+                if (!seen.has(row.id)) {
+                    seen.add(row.id);
+                    rows.push(row);
+                    if (rows.length >= limit) return rows;
+                }
+            }
+        }
+        return rows;
+    } catch (_) {
+        return [];
+    }
+}
+
+function clearInteractionMemories() {
+    try {
+        getDb().prepare('DELETE FROM interaction_memories').run();
+    } catch (err) {
+        console.error('[Memory] clearInteractionMemories error:', err.message);
+    }
+}
+
+function exportMemorySnapshot() {
+    try {
+        return {
+            profile: getAllProfile(),
+            session_memories: getRecentMemories(MAX_SESSION_MEMORIES),
+            usage_patterns: getTopPatterns(50),
+            interaction_memories: getRecentInteractions(MAX_INTERACTION_MEMORIES)
+        };
+    } catch (err) {
+        console.error('[Memory] exportMemorySnapshot error:', err.message);
+        return {
+            profile: {},
+            session_memories: [],
+            usage_patterns: [],
+            interaction_memories: []
+        };
+    }
+}
+
 // ── Simple keyword extractor (no external deps) ────────────────────────────
 const STOP_WORDS = new Set([
     'ที่', 'ให้', 'และ', 'ของ', 'กับ', 'ใน', 'บน', 'เป็น', 'อยู่', 'มี', 'ได้', 'the', 'a', 'an',
@@ -220,6 +362,37 @@ function extractKeywords(text) {
         .slice(0, 6);
 }
 
+function cleanProfileValue(value) {
+    return String(value || '')
+        .replace(/[.,!?;:()[\]{}"'`“”‘’]+$/g, '')
+        .replace(/(นะ|น่ะ|ครับ|ค่ะ|คะ|จ้า|จ๊ะ|ฮะ|ค้าบ|ค่า)+$/u, '')
+        .trim();
+}
+
+function extractUserName(text) {
+    const input = String(text || '').trim();
+    const patterns = [
+        /(?:ผม|ฉัน|ชั้น|หนู|เรา|ข้า|ดิฉัน)?\s*ชื่อ(?:เล่น)?\s*(?:คือ|ว่า|เป็น)?\s*([A-Za-z\u0E00-\u0E7F][A-Za-z\u0E00-\u0E7F\s]{0,40})/iu,
+        /(?:เรียก(?:ผม|ฉัน|ชั้น|หนู|เรา)?ว่า)\s*([A-Za-z\u0E00-\u0E7F][A-Za-z\u0E00-\u0E7F\s]{0,40})/iu,
+        /\bmy name is\s+([A-Za-z][A-Za-z\s'-]{0,40})/iu,
+        /\bcall me\s+([A-Za-z][A-Za-z\s'-]{0,40})/iu,
+        /\bi am\s+([A-Za-z][A-Za-z\s'-]{0,40})/iu,
+        /\bi'm\s+([A-Za-z][A-Za-z\s'-]{0,40})/iu
+    ];
+
+    for (const pattern of patterns) {
+        const match = input.match(pattern);
+        if (match && match[1]) {
+            const name = cleanProfileValue(match[1])
+                .split(/\s+(?:and|แล้ว|นะ|ครับ|ค่ะ|คะ)\s+/i)[0]
+                .trim();
+            if (name && name.length <= 40) return name;
+        }
+    }
+
+    return '';
+}
+
 // ── Main public API ────────────────────────────────────────────────────────
 
 /**
@@ -233,12 +406,18 @@ function recordInteraction(userMessage, aiResponseText) {
         // Extract keywords as usage patterns
         const keywords = extractKeywords(userMessage);
         keywords.forEach(kw => recordPattern(kw));
+        addInteractionMemory(userMessage, aiResponseText, keywords);
 
         // Detect preferred language
         const thaiRatio = (userMessage.match(/[\u0E00-\u0E7F]/g) || []).length / userMessage.length;
         if (thaiRatio > 0.3) setProfile('preferred_language', 'thai');
         else setProfile('preferred_language', 'english');
 
+        const userName = extractUserName(userMessage);
+        if (userName) {
+            setProfile('user_name', userName);
+        }
+
         // Detect coding intent (update project activity)
         const codingKeywords = ['code', 'fix', 'debug', 'function', 'class', 'import', 'script',
             'แก้', 'เขียน', 'โค้ด', 'สคริปต์', 'ฟังก์ชัน'];
@@ -268,20 +447,86 @@ function saveSessionSummary(summary, tags = []) {
     addSessionMemory(summary.trim(), tags);
 }
 
+function addLearnedSkill(name, sourcePath, content) {
+    const cleanName = String(name || '').trim() || path.basename(sourcePath || 'skill.md');
+    const cleanPath = path.resolve(String(sourcePath || ''));
+    const cleanContent = String(content || '').trim();
+    if (!cleanContent) {
+        throw new Error('Skill file is empty.');
+    }
+
+    const storedContent = cleanContent.slice(0, 12000);
+    ensureLearnedSkillsTable();
+    const db = getDb();
+    db.prepare(`
+        INSERT INTO learned_skills (name, source_path, content, created_at, updated_at)
+        VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+        ON CONFLICT(source_path) DO UPDATE SET
+            name = excluded.name,
+            content = excluded.content,
+            updated_at = CURRENT_TIMESTAMP
+    `).run(cleanName, cleanPath, storedContent);
+
+    return {
+        name: cleanName,
+        source_path: cleanPath,
+        content_length: cleanContent.length,
+        stored_length: storedContent.length
+    };
+}
+
+function getLearnedSkills(limit = 10) {
+    try {
+        ensureLearnedSkillsTable();
+        return getDb().prepare(`
+            SELECT id, name, source_path, content, created_at, updated_at
+            FROM learned_skills
+            ORDER BY updated_at DESC, id DESC
+            LIMIT ?
+        `).all(limit);
+    } catch (err) {
+        console.error('[Memory] getLearnedSkills error:', err.message);
+        return [];
+    }
+}
+
+function deleteLearnedSkill(identifier) {
+    try {
+        ensureLearnedSkillsTable();
+        const input = String(identifier || '').trim();
+        if (!input) return 0;
+
+        const db = getDb();
+        if (/^\d+$/.test(input)) {
+            return db.prepare('DELETE FROM learned_skills WHERE id = ?').run(Number(input)).changes;
+        }
+
+        const resolved = path.resolve(input);
+        return db.prepare('DELETE FROM learned_skills WHERE source_path = ? OR name = ?').run(resolved, input).changes;
+    } catch (err) {
+        console.error('[Memory] deleteLearnedSkill error:', err.message);
+        return 0;
+    }
+}
+
 /**
  * Returns a formatted context string to inject into the AI system prompt.
  * Lightweight — no async calls.
  */
-function getUserContext() {
+function getUserContext(query = '') {
     try {
         const profile = getAllProfile();
         const patterns = getTopPatterns(6);
         const memories = getRecentMemories(3);
+        const interactions = getRecentInteractions(6);
+        const relevantInteractions = query ? searchInteractions(query, 5) : [];
 
         const lines = ['\n\n[LONG-TERM USER CONTEXT — use this to personalize responses]'];
 
         // Profile info
         if (Object.keys(profile).length > 0) {
+            if (profile.user_name)
+                lines.push(`• User name: ${profile.user_name}`);
             if (profile.preferred_language)
                 lines.push(`• Previously inferred language: ${profile.preferred_language} (do not override the current user message language)`);
             if (profile.last_active_project)
@@ -306,6 +551,36 @@ function getUserContext() {
             memories.forEach((m, i) => lines.push(`  ${i + 1}. ${m.summary}`));
         }
 
+        if (interactions.length > 0) {
+            lines.push('\nRecent remembered interactions:');
+            interactions.forEach((m, i) => {
+                lines.push(`  ${i + 1}. User: ${m.user_text}`);
+                lines.push(`     Mint: ${m.ai_text}`);
+            });
+        }
+
+        if (relevantInteractions.length > 0) {
+            lines.push('\nRelevant remembered interactions for the current request:');
+            relevantInteractions.forEach((m, i) => {
+                lines.push(`  ${i + 1}. User: ${m.user_text}`);
+                lines.push(`     Mint: ${m.ai_text}`);
+            });
+        }
+
+        const learnedSkills = getLearnedSkills(8);
+        if (learnedSkills.length > 0) {
+            lines.push('\nLearned skill/instruction files:');
+            learnedSkills.forEach((skill, i) => {
+                lines.push(`\n  ${i + 1}. ${skill.name}`);
+                lines.push(`     Source: ${skill.source_path}`);
+                lines.push('     Content:');
+                lines.push(skill.content
+                    .split('\n')
+                    .map(line => `       ${line}`)
+                    .join('\n'));
+            });
+        }
+
         if (lines.length === 1) return ''; // nothing to add
         lines.push('[END USER CONTEXT]\n');
         return lines.join('\n');
@@ -324,7 +599,11 @@ function getCachedResponse(query) {
             // Optional: check TTL (e.g., 24 hours)
             const age = Date.now() - new Date(row.created_at).getTime();
             if (age < 24 * 60 * 60 * 1000) {
-                return JSON.parse(row.response);
+                const parsed = JSON.parse(row.response);
+                if (parsed && typeof parsed.response === 'string') {
+                    parsed.response = stripRelevantMemoryBlock(parsed.response);
+                }
+                return parsed;
             }
         }
     } catch (_) {}
@@ -334,11 +613,19 @@ function getCachedResponse(query) {
 function cacheResponse(query, responseObj) {
     try {
         const hash = crypto.createHash('md5').update(query.trim().toLowerCase()).digest('hex');
+        const sanitized = (responseObj && typeof responseObj === 'object')
+            ? {
+                ...responseObj,
+                response: typeof responseObj.response === 'string'
+                    ? stripRelevantMemoryBlock(responseObj.response)
+                    : responseObj.response
+            }
+            : responseObj;
         getDb().prepare(`
             INSERT INTO response_cache (query_hash, response, created_at)
             VALUES (?, ?, CURRENT_TIMESTAMP)
             ON CONFLICT(query_hash) DO UPDATE SET response = excluded.response, created_at = CURRENT_TIMESTAMP
-        `).run(hash, JSON.stringify(responseObj));
+        `).run(hash, JSON.stringify(sanitized));
     } catch (_) {}
 }
 
@@ -358,7 +645,16 @@ module.exports = {
     deleteProfile,
     clearConversationScopedProfile,
     getProfile,
+    getAllProfile,
+    addLearnedSkill,
+    getLearnedSkills,
+    deleteLearnedSkill,
     getTopPatterns,
+    getRecentInteractions,
+    searchInteractions,
+    deleteInteractionMemory,
+    clearInteractionMemories,
+    exportMemorySnapshot,
     getRecentMemories,
     getCachedResponse,
     cacheResponse,

package/src/AI_Brain/proactive_engine.js

@@ -5,9 +5,14 @@ const { readConfig } = require('../System/config_manager');
 // Proactive Engine — Smart Suggestion Engine (Multi-Choice)
 // ============================================================
 
-const ai = new GoogleGenAI({});
 const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
 let lastLoggedModel = '';
+let _ai = null;
+
+function getAi(apiKey) {
+    if (!_ai) _ai = new GoogleGenAI({ apiKey });
+    return _ai;
+}
 
 const PROACTIVE_SYSTEM_PROMPT = `You are a Smart Suggestion Engine built into a Desktop AI Agent called "Mint".
 Your job: observe the user's screen + behavior, then offer MULTIPLE relevant quick-action options — NOT just one question.
@@ -89,11 +94,15 @@ function getMinSuggestionIntervalMs() {
  */
 async function analyzeAndSuggest(base64Image, behaviorSummary) {
     try {
-        const model = resolveGeminiModel();
+        const cfg = readConfig();
+        const apiKey = cfg.apiKey || process.env.GEMINI_API_KEY;
+        if (!apiKey) return null; // silently skip if no API key configured
+        const model = (cfg.geminiModel || '').trim() || DEFAULT_GEMINI_MODEL;
         if (model && model !== lastLoggedModel) {
             console.log(`[Gemini] Proactive Engine model: ${model}`);
             lastLoggedModel = model;
         }
+        const ai = getAi(apiKey);
 
         const now = Date.now();
         const minInterval = getMinSuggestionIntervalMs();
@@ -127,6 +136,7 @@ Rules: Only suggest if you see a clear opportunity. Return 2–4 relevant chips.
             contents: [{ role: 'user', parts: userMessage }]
         });
 
+
         let parsed;
         try {
             parsed = JSON.parse(response.text);

package/src/Automation_Layer/browser_automation.js

@@ -1,10 +1,10 @@
-const puppeteer = require('puppeteer');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { GoogleGenAI } = require('@google/genai');
 const { readConfig } = require('../System/config_manager');
 
-const ai = new GoogleGenAI({});
-const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
-let lastLoggedModel = '';
+
 
 const BROWSER_SYSTEM_PROMPT = `You are an Autonomous Browser Agent. Your goal is to fulfill the user's web instruction by driving a headless browser.
 
@@ -24,6 +24,9 @@ Actions:
 
 You will receive the result of your previous action in the next message. If you get stuck or fail, try another approach or use "done" to report the failure.`;
 
+const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
+let lastLoggedModel = '';
+
 function resolveGeminiModel() {
     try {
         const cfg = readConfig();
@@ -35,11 +38,14 @@ function resolveGeminiModel() {
 }
 
 async function performWebAutomation(query) {
-    if (!query) return "No query provided.";
+    if (!query) return 'No query provided.';
 
-    console.log("Starting web automation for:", query);
+    // Dynamic require — user must install puppeteer separately
+    const puppeteer = requireOptional('puppeteer', 'npm install puppeteer');
 
     const config = readConfig();
+    const apiKey  = config.apiKey || process.env.GEMINI_API_KEY;
+    const ai = new GoogleGenAI({ apiKey });
     const browserPath = config.automationBrowser;
 
     let browser;
@@ -50,7 +56,6 @@ async function performWebAutomation(query) {
             args: ['--start-maximized']
         };
 
-        // If it's a specific path (like /usr/bin/firefox), set executablePath
         if (browserPath && browserPath !== 'chromium') {
             launchOptions.executablePath = browserPath;
             if (browserPath.toLowerCase().includes('firefox')) {
@@ -59,9 +64,8 @@ async function performWebAutomation(query) {
         }
 
         browser = await puppeteer.launch(launchOptions);
-
         const page = await browser.newPage();
-        
+
         const model = resolveGeminiModel();
         if (model && model !== lastLoggedModel) {
             console.log(`[Gemini] Web Automation model: ${model}`);
@@ -72,12 +76,12 @@ async function performWebAutomation(query) {
             model,
             config: {
                 systemInstruction: BROWSER_SYSTEM_PROMPT,
-                responseMimeType: "application/json"
+                responseMimeType: 'application/json'
             }
         });
 
         let currentObservation = `Goal: ${query}\nSystem Note: You have a blank browser page. What is your first action? Start by using "goto" to navigate to a relevant search engine or website.`;
-        
+
         let maxSteps = 10;
         let step = 0;
 
@@ -87,27 +91,26 @@ async function performWebAutomation(query) {
             console.log(`Observation:`, currentObservation.substring(0, 150) + (currentObservation.length > 150 ? '...' : ''));
 
             const response = await chat.sendMessage({ message: currentObservation });
-            
+
             let parsed;
             try {
                 const text = response.text;
                 const cleanText = text.replace(/^```json\n/, '').replace(/\n```$/, '').trim();
                 parsed = JSON.parse(cleanText);
             } catch (e) {
-                console.error("Agent failed to return valid JSON:", response.text);
-                currentObservation = "Error: Invalid JSON returned. Please reply with ONLY valid JSON matching the schema.";
+                console.error('Agent failed to return valid JSON:', response.text);
+                currentObservation = 'Error: Invalid JSON returned. Please reply with ONLY valid JSON matching the schema.';
                 continue;
             }
 
-            console.log("Agent Thought:", parsed.thought);
-            console.log("Agent Action:", parsed.action);
-            console.log("Agent Target:", parsed.target);
+            console.log('Agent Thought:', parsed.thought);
+            console.log('Agent Action:', parsed.action);
+            console.log('Agent Target:', parsed.target);
 
             const { action, target } = parsed;
 
             if (action === 'done') {
-                console.log("Agent finished with answer:", target);
-                // Intentionally keeping the browser open so the user can see the page.
+                console.log('Agent finished with answer:', target);
                 return `🤖 Web Automation Result: ${target}`;
             }
 
@@ -119,7 +122,7 @@ async function performWebAutomation(query) {
                 } else if (action === 'click') {
                     await page.waitForSelector(target, { timeout: 5000 });
                     await page.click(target);
-                    await new Promise(r => setTimeout(r, 2000)); 
+                    await new Promise(r => setTimeout(r, 2000));
                     const pageTitle = await page.title();
                     currentObservation = `Clicked element. Current page: ${pageTitle}. ` + await page.evaluate(() => document.body.innerText.substring(0, 1500));
                 } else if (action === 'eval') {
@@ -129,16 +132,15 @@ async function performWebAutomation(query) {
                     currentObservation = `Error: Unknown action type "${action}".`;
                 }
             } catch (actionError) {
-                console.error("Action execution failed:", actionError);
+                console.error('Action execution failed:', actionError);
                 currentObservation = `Action failed: ${actionError.message}. Please try again or use another method (for instance, try a different CSS selector or just read the current page).`;
             }
         }
 
-        // Intentionally keeping the browser open
-        return "Agent reached maximum steps (10) without finding a final answer.";
+        return 'Agent reached maximum steps (10) without finding a final answer.';
 
     } catch (error) {
-        console.error("Web Automation Error:", error);
+        console.error('Web Automation Error:', error);
         if (browser) browser.close();
         return `I encountered an overall error while automating the browser: ${error.message}`;
     }

package/src/CLI/approval_handler.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const readline = require('readline');
+const { colors } = require('./cli_colors');
+
+/**
+ * Prompts the user in the terminal to approve or deny a code-agent action.
+ * Used by the non-interactive `mint code <task>` command.
+ *
+ * @param {{ type: string, label?: string, preview?: string }} request
+ * @returns {Promise<boolean>}  true = approved, false = denied
+ */
+async function requestCodeApproval(request) {
+    const typeLabel =
+        request.type === 'shell' ? 'Shell Command' :
+        request.type === 'patch' ? 'Patch Edit'    :
+        'File Write';
+
+    console.log(`\n${colors.yellow}${colors.bright}[Approval Required]${colors.reset} ${typeLabel}`);
+    if (request.label)   console.log(`${colors.gray}${request.label}${colors.reset}`);
+    if (request.preview) console.log(`${colors.gray}${request.preview}${colors.reset}\n`);
+
+    const rl = readline.createInterface({
+        input:  process.stdin,
+        output: process.stdout
+    });
+
+    const answer = await new Promise((resolve) => {
+        rl.question('Approve this action? [y/N]: ', (value) => {
+            rl.close();
+            resolve((value || '').trim().toLowerCase());
+        });
+    });
+
+    const approved = answer === 'y' || answer === 'yes';
+    console.log(approved
+        ? `${colors.mint}[Mint Code] Approved.${colors.reset}\n`
+        : `${colors.pink}[Mint Code] Denied.${colors.reset}\n`);
+    return approved;
+}
+
+module.exports = { requestCodeApproval };

package/src/CLI/chat_router.js

@@ -187,6 +187,7 @@ async function runChatRoutedTask(input, context) {
     }, 1000);
 
     try {
+        let streamedFinalSummary = false;
         const result = await executeCodeTask(text, {
             cwd: process.cwd(),
             requestApproval,
@@ -199,21 +200,32 @@ async function runChatRoutedTask(input, context) {
                 } else {
                     appendMessage('system', `[Code] ${typeof info === 'string' ? info : (info.action || info.phase)}`);
                 }
+            },
+            onFinalSummary: async (info) => {
+                if (typeof context.streamAssistantSentences !== 'function') {
+                    return;
+                }
+                clearInterval(timer);
+                setThinking(false);
+                streamedFinalSummary = true;
+                await context.streamAssistantSentences(info.summary, appendMessage, { providerInfo: info.providerInfo }, context.streamMessage);
             }
         });
         clearInterval(timer);
         setThinking(false);
-        appendMessage('assistant', [
-            `Code Mode finished.`,
-            result.summary,
-            `Verification: ${result.verification}`
-        ].join('\n'), { providerInfo: result.providerInfo });
+        if (!streamedFinalSummary) {
+            appendMessage('assistant', [
+                `Code Mode finished.`,
+                result.summary,
+                `Verification: ${result.verification}`
+            ].join('\n'), { providerInfo: result.providerInfo });
+        }
     } catch (error) {
         clearInterval(timer);
         setThinking(false);
         appendMessage('error', error.message);
     } finally {
-        if (setMode) setMode('Chat');
+        if (setMode) setMode('Agent');
     }
 }