@pheem49/mint 1.3.0 → 1.4.0

package/src/AI_Brain/memory_store.js

@@ -0,0 +1,318 @@
+/**
+ * Mint Long-Term Memory Store
+ * ---------------------------
+ * Persists user preferences, session summaries, and usage patterns
+ * across all Mint sessions using SQLite (same DB as knowledge_base).
+ *
+ * Auto-injects a "User Context" block into the system prompt so Mint
+ * remembers who it's talking to even after restart.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { readConfig } = require('../System/config_manager');
+
+// ── Electron-safe app path ──────────────────────────────────────────────────
+let app;
+try {
+    const electron = require('electron');
+    app = electron.app;
+} catch (_) {
+    app = null;
+}
+
+function getDbPath() {
+    const fileName = 'mint-knowledge.sqlite'; // shared DB with knowledge_base
+    if (app && app.getPath) {
+        return path.join(app.getPath('userData'), fileName);
+    }
+    const mintDir = path.join(os.homedir(), '.mint');
+    if (!fs.existsSync(mintDir)) fs.mkdirSync(mintDir, { recursive: true });
+    return path.join(mintDir, fileName);
+}
+
+// ── Lazy DatabaseSync init ─────────────────────────────────────────────────
+let DatabaseSync = null;
+function getDatabaseSync() {
+    if (!DatabaseSync) ({ DatabaseSync } = require('node:sqlite'));
+    return DatabaseSync;
+}
+
+let dbInstance = null;
+function getDb() {
+    if (dbInstance) return dbInstance;
+    const Database = getDatabaseSync();
+    dbInstance = new Database(getDbPath());
+
+    dbInstance.exec(`
+        -- User profile: arbitrary key-value pairs
+        CREATE TABLE IF NOT EXISTS user_profile (
+            key        TEXT PRIMARY KEY,
+            value      TEXT,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+
+        -- Condensed summaries of past sessions
+        CREATE TABLE IF NOT EXISTS session_memories (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            summary    TEXT NOT NULL,
+            tags       TEXT DEFAULT '',
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+
+        -- Frequently used topics / commands
+        CREATE TABLE IF NOT EXISTS usage_patterns (
+            pattern   TEXT PRIMARY KEY,
+            count     INTEGER DEFAULT 1,
+            last_used 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
+        );
+    `);
+
+    return dbInstance;
+}
+
+// ── Profile helpers ────────────────────────────────────────────────────────
+function setProfile(key, value) {
+    try {
+        const db = getDb();
+        db.prepare(`
+            INSERT INTO user_profile (key, value, updated_at)
+            VALUES (?, ?, CURRENT_TIMESTAMP)
+            ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = CURRENT_TIMESTAMP
+        `).run(key, String(value));
+    } catch (err) {
+        console.error('[Memory] setProfile error:', err.message);
+    }
+}
+
+function getProfile(key, defaultValue = null) {
+    try {
+        const row = getDb().prepare('SELECT value FROM user_profile WHERE key = ?').get(key);
+        return row ? row.value : defaultValue;
+    } catch (_) {
+        return defaultValue;
+    }
+}
+
+function getAllProfile() {
+    try {
+        const rows = getDb().prepare('SELECT key, value FROM user_profile').all();
+        return Object.fromEntries(rows.map(r => [r.key, r.value]));
+    } catch (_) {
+        return {};
+    }
+}
+
+// ── Session memory helpers ─────────────────────────────────────────────────
+const MAX_SESSION_MEMORIES = 20; // keep last N summaries
+
+function addSessionMemory(summary, tags = []) {
+    try {
+        const db = getDb();
+        db.prepare('INSERT INTO session_memories (summary, tags) VALUES (?, ?)').run(
+            summary.slice(0, 800), // cap length
+            tags.join(',')
+        );
+        // Prune oldest beyond limit
+        db.exec(`
+            DELETE FROM session_memories WHERE id NOT IN (
+                SELECT id FROM session_memories ORDER BY id DESC LIMIT ${MAX_SESSION_MEMORIES}
+            )
+        `);
+    } catch (err) {
+        console.error('[Memory] addSessionMemory error:', err.message);
+    }
+}
+
+function getRecentMemories(limit = 5) {
+    try {
+        return getDb()
+            .prepare('SELECT summary, tags, created_at FROM session_memories ORDER BY id DESC LIMIT ?')
+            .all(limit);
+    } catch (_) {
+        return [];
+    }
+}
+
+// ── Usage pattern helpers ──────────────────────────────────────────────────
+function recordPattern(pattern) {
+    try {
+        const db = getDb();
+        db.prepare(`
+            INSERT INTO usage_patterns (pattern, count, last_used)
+            VALUES (?, 1, CURRENT_TIMESTAMP)
+            ON CONFLICT(pattern) DO UPDATE
+            SET count = count + 1, last_used = CURRENT_TIMESTAMP
+        `).run(pattern.slice(0, 120));
+    } catch (_) {}
+}
+
+function getTopPatterns(limit = 8) {
+    try {
+        return getDb()
+            .prepare('SELECT pattern, count FROM usage_patterns ORDER BY count DESC, last_used DESC LIMIT ?')
+            .all(limit);
+    } catch (_) {
+        return [];
+    }
+}
+
+// ── Simple keyword extractor (no external deps) ────────────────────────────
+const STOP_WORDS = new Set([
+    'ที่', 'ให้', 'และ', 'ของ', 'กับ', 'ใน', 'บน', 'เป็น', 'อยู่', 'มี', 'ได้', 'the', 'a', 'an',
+    'is', 'are', 'was', 'were', 'it', 'in', 'on', 'at', 'for', 'to', 'of', 'with', 'and', 'or',
+    'this', 'that', 'i', 'you', 'me', 'my', 'your', 'can', 'do', 'be', 'will', 'please', 'how',
+    'what', 'which', 'when', 'where', 'why', 'help', 'want', 'need', 'make', 'create', 'get', 'run'
+]);
+
+function extractKeywords(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\u0E00-\u0E7F\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !STOP_WORDS.has(w))
+        .slice(0, 6);
+}
+
+// ── Main public API ────────────────────────────────────────────────────────
+
+/**
+ * Called after every successful chat turn.
+ * Extracts patterns & infers preferences — runs async, non-blocking.
+ */
+function recordInteraction(userMessage, aiResponseText) {
+    try {
+        if (!userMessage || !aiResponseText) return;
+
+        // Extract keywords as usage patterns
+        const keywords = extractKeywords(userMessage);
+        keywords.forEach(kw => recordPattern(kw));
+
+        // 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');
+
+        // Detect coding intent (update project activity)
+        const codingKeywords = ['code', 'fix', 'debug', 'function', 'class', 'import', 'script',
+            'แก้', 'เขียน', 'โค้ด', 'สคริปต์', 'ฟังก์ชัน'];
+        if (codingKeywords.some(k => userMessage.toLowerCase().includes(k))) {
+            const cwd = process.cwd();
+            if (cwd !== os.homedir()) {
+                setProfile('last_active_project', path.basename(cwd));
+                setProfile('last_active_project_path', cwd);
+            }
+        }
+
+        // Update interaction counter
+        const count = parseInt(getProfile('total_interactions', '0'), 10);
+        setProfile('total_interactions', String(count + 1));
+        setProfile('last_seen', new Date().toISOString());
+    } catch (err) {
+        console.error('[Memory] recordInteraction error:', err.message);
+    }
+}
+
+/**
+ * Saves a condensed summary of a completed conversation.
+ * Call this when user clears history or after N turns.
+ */
+function saveSessionSummary(summary, tags = []) {
+    if (!summary || summary.trim().length < 10) return;
+    addSessionMemory(summary.trim(), tags);
+}
+
+/**
+ * Returns a formatted context string to inject into the AI system prompt.
+ * Lightweight — no async calls.
+ */
+function getUserContext() {
+    try {
+        const profile = getAllProfile();
+        const patterns = getTopPatterns(6);
+        const memories = getRecentMemories(3);
+
+        const lines = ['\n\n[LONG-TERM USER CONTEXT — use this to personalize responses]'];
+
+        // Profile info
+        if (Object.keys(profile).length > 0) {
+            if (profile.preferred_language)
+                lines.push(`• Preferred language: ${profile.preferred_language}`);
+            if (profile.last_active_project)
+                lines.push(`• Last active project: ${profile.last_active_project} (${profile.last_active_project_path || ''})`);
+            if (profile.total_interactions)
+                lines.push(`• Total interactions with Mint: ${profile.total_interactions}`);
+            if (profile.last_seen) {
+                const d = new Date(profile.last_seen);
+                lines.push(`• Last session: ${d.toLocaleDateString('th-TH')} ${d.toLocaleTimeString('th-TH', { hour: '2-digit', minute: '2-digit' })}`);
+            }
+        }
+
+        // Usage patterns
+        if (patterns.length > 0) {
+            const topTopics = patterns.map(p => p.pattern).join(', ');
+            lines.push(`• Frequent topics/tools: ${topTopics}`);
+        }
+
+        // Past session memories
+        if (memories.length > 0) {
+            lines.push('\nRecent session summaries:');
+            memories.forEach((m, i) => lines.push(`  ${i + 1}. ${m.summary}`));
+        }
+
+        if (lines.length === 1) return ''; // nothing to add
+        lines.push('[END USER CONTEXT]\n');
+        return lines.join('\n');
+    } catch (err) {
+        console.error('[Memory] getUserContext error:', err.message);
+        return '';
+    }
+}
+
+// ── Response Cache helpers ────────────────────────────────────────────────
+function getCachedResponse(query) {
+    try {
+        const hash = crypto.createHash('md5').update(query.trim().toLowerCase()).digest('hex');
+        const row = getDb().prepare('SELECT response, created_at FROM response_cache WHERE query_hash = ?').get(hash);
+        if (row) {
+            // 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);
+            }
+        }
+    } catch (_) {}
+    return null;
+}
+
+function cacheResponse(query, responseObj) {
+    try {
+        const hash = crypto.createHash('md5').update(query.trim().toLowerCase()).digest('hex');
+        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));
+    } catch (_) {}
+}
+
+module.exports = {
+    recordInteraction,
+    saveSessionSummary,
+    getUserContext,
+    setProfile,
+    getProfile,
+    getTopPatterns,
+    getRecentMemories,
+    getCachedResponse,
+    cacheResponse
+};

package/src/CLI/chat_router.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { GoogleGenAI } = require('@google/genai');
 const { executeCodeTask } = require('./code_agent');
-const { readConfig } = require('../System/config_manager');
+const { readConfig, getAvailableProviders } = require('../System/config_manager');
 
 const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
 
@@ -128,7 +128,21 @@ async function runChatRoutedTask(input, context) {
     const text = input.startsWith('/code ') ? input.slice('/code '.length).trim() : input;
     const { appendMessage, setThinking, requestApproval, setMode } = context;
 
-    appendMessage('system', `Routing this request to Code Mode for workspace: ${process.cwd()}`);
+    const config = readConfig();
+    const availableProviders = getAvailableProviders(config);
+    
+    // Smart Routing Priority for Code Tasks
+    let preferredProvider = config.aiProvider || 'gemini'; 
+    
+    // If preferred isn't actually available, try best available
+    if (!availableProviders.includes(preferredProvider)) {
+        if (availableProviders.includes('anthropic')) preferredProvider = 'anthropic';
+        else if (availableProviders.includes('openai')) preferredProvider = 'openai';
+        else if (availableProviders.includes('gemini')) preferredProvider = 'gemini';
+        else preferredProvider = availableProviders[0] || 'gemini';
+    }
+
+    appendMessage('system', `Routing this request to Code Mode for workspace: ${process.cwd()} using [${preferredProvider}]`);
     if (setMode) setMode('Code');
 
     let seconds = 0;
@@ -142,6 +156,7 @@ async function runChatRoutedTask(input, context) {
         const result = await executeCodeTask(text, {
             cwd: process.cwd(),
             requestApproval,
+            provider: preferredProvider,
             onProgress: (message) => appendMessage('system', `[Code] ${message}`)
         });
         clearInterval(timer);

package/src/CLI/chat_ui.js

@@ -14,6 +14,10 @@ const SLASH_COMMANDS = [
     { name: '/copy',   desc: 'Copy last response to clipboard' },
     { name: '/clear',  desc: 'Clear conversation history' },
     { name: '/reset',  desc: 'Reset conversation history' },
+    { name: '/agent',  desc: 'Switch AI personas (coder, researcher, etc)' },
+    { name: '/workspace', desc: 'Manage project-specific contexts' },
+    { name: '/review', desc: 'Request a second-pass review of the last response' },
+    { name: '/stats',  desc: 'Show system health stats (CPU/RAM/Disk)' },
     { name: '/help',   desc: 'Show help information' },
     { name: '/exit',   desc: 'Exit Mint' }
 ];
@@ -588,6 +592,84 @@ function createChatUI({ onSubmit, onExit }) {
         screen.render();
     }
 
+    /**
+     * Opens a streaming message bubble for the assistant.
+     * Returns { appendChunk(text), finalize(timestamp) } for typewriter rendering.
+     * Usage:
+     *   const stream = streamMessage('assistant');
+     *   stream.appendChunk('Hello'); stream.appendChunk(' World');
+     *   stream.finalize(timestamp);
+     */
+    function streamMessage(role = 'assistant') {
+        const now = new Date();
+        const timeStr = now.toLocaleTimeString('th-TH', { hour: '2-digit', minute: '2-digit', hour12: false });
+        const maxLineWidth = Math.max(screen.width - 20, 36);
+
+        // Print the header bubble once
+        chatBox.log('');
+        if (role === 'assistant') {
+            chatBox.log(` {bold}{#d4a8ff-fg}Mint{/} {gray-fg}${timeStr}{/}`);
+        }
+
+        let buffer = '';           // accumulates the full response text
+        let lineBuffer = '';       // current partial line being built
+        let lineRendered = false;  // whether we already pushed the first line prefix
+
+        function flushLine(force = false) {
+            // Flush content that fits on one line-width or when forced
+            if (!lineBuffer && !force) return;
+            if (!lineRendered) {
+                chatBox.log(` {#5a456d-fg}▏{/} {#ffffff-fg}${lineBuffer}{/}`);
+                lineRendered = true;
+            } else {
+                // Overwrite the last line by popping + re-pushing (blessed.log limitation)
+                // We can't truly overwrite, so we just keep appending new lines for each chunk.
+                // For large chunks, split on newline and emit per-line.
+                chatBox.log(` {#5a456d-fg}▏{/} {#ffffff-fg}${lineBuffer}{/}`);
+            }
+            screen.render();
+        }
+
+        function appendChunk(text) {
+            if (!text) return;
+            buffer += text;
+            const segments = text.split('\n');
+            for (let i = 0; i < segments.length; i++) {
+                lineBuffer += segments[i];
+                if (i < segments.length - 1) {
+                    // Newline boundary — emit current line
+                    const lines = wrapLineSmart(lineBuffer, maxLineWidth);
+                    lines.forEach(l => chatBox.log(` {#5a456d-fg}▏{/} {#ffffff-fg}${l}{/}`));
+                    lineBuffer = '';
+                    lineRendered = true;
+                    screen.render();
+                } else if (lineBuffer.length >= maxLineWidth) {
+                    // Line overflow — auto-wrap
+                    const lines = wrapLineSmart(lineBuffer, maxLineWidth);
+                    lines.slice(0, -1).forEach(l => chatBox.log(` {#5a456d-fg}▏{/} {#ffffff-fg}${l}{/}`));
+                    lineBuffer = lines[lines.length - 1] || '';
+                    lineRendered = true;
+                    screen.render();
+                }
+                // Otherwise keep buffering the partial line
+            }
+        }
+
+        function finalize(timestamp = null) {
+            // Flush remaining buffer
+            if (lineBuffer) {
+                const lines = wrapLineSmart(lineBuffer, maxLineWidth);
+                lines.forEach(l => chatBox.log(` {#5a456d-fg}▏{/} {#ffffff-fg}${l}{/}`));
+                lineBuffer = '';
+            }
+            // Track last response for clipboard
+            lastAssistantResponse = buffer;
+            screen.render();
+        }
+
+        return { appendChunk, finalize };
+    }
+
     /** Show/hide thinking indicator in status bar */
     function setThinking(active, secondsElapsed = 0) {
         if (active) {
@@ -628,7 +710,7 @@ function createChatUI({ onSubmit, onExit }) {
         });
     }
 
-    return { screen, appendMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode };
+    return { screen, appendMessage, streamMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode };
 }
 
 module.exports = { createChatUI };

package/src/CLI/code_agent.js

@@ -3,7 +3,8 @@ const path = require('path');
 const { execFile } = require('child_process');
 const { promisify } = require('util');
 const { GoogleGenAI } = require('@google/genai');
-const { readConfig } = require('../System/config_manager');
+const axios = require('axios');
+const { readConfig, getAvailableProviders } = require('../System/config_manager');
 const { readWorkspaceSession, writeWorkspaceSession } = require('./code_session_memory');
 
 const execFileAsync = promisify(execFile);
@@ -244,16 +245,101 @@ function writeFile(workspaceRoot, targetPath, content) {
     return `Wrote ${targetPath}`;
 }
 
-function getAiClientAndModel() {
-    const config = readConfig();
-    const apiKey = (config.apiKey || process.env.GEMINI_API_KEY || '').trim();
-    if (!apiKey) {
-        throw new Error("Missing Gemini API key. Run 'mint onboard' first.");
+class UnifiedAgentClient {
+    constructor(provider, config) {
+        this.provider = provider;
+        this.config = config;
+        this.history = [];
+        this.systemInstruction = CODE_AGENT_PROMPT;
+    }
+
+    async sendMessage(observation) {
+        this.history.push({ role: 'user', content: observation });
+
+        let responseText = '';
+        if (this.provider === 'anthropic') {
+            responseText = await this._callAnthropic();
+        } else if (this.provider === 'openai' || this.provider === 'local_openai') {
+            responseText = await this._callOpenAI();
+        } else {
+            responseText = await this._callGemini();
+        }
+
+        this.history.push({ role: 'assistant', content: responseText });
+        return responseText;
+    }
+
+    async _callAnthropic() {
+        const apiKey = this.config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+        const messages = this.history.map(m => ({
+            role: m.role,
+            content: m.content
+        }));
+
+        const response = await axios.post('https://api.anthropic.com/v1/messages', {
+            model: this.config.anthropicModel || 'claude-3-5-sonnet-latest',
+            max_tokens: 8192,
+            system: this.systemInstruction,
+            messages: messages
+        }, {
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json'
+            }
+        });
+        return response.data.content[0].text;
+    }
+
+    async _callOpenAI() {
+        const isLocal = this.provider === 'local_openai';
+        const apiKey = isLocal ? 'not-needed' : (this.config.openaiApiKey || process.env.OPENAI_API_KEY);
+        const baseUrl = isLocal ? (this.config.localApiBaseUrl || 'http://localhost:1234/v1') : 'https://api.openai.com/v1';
+        const model = isLocal ? (this.config.localModelName || 'local-model') : (this.config.openaiModel || 'gpt-4o');
+
+        const messages = [
+            { role: 'system', content: this.systemInstruction },
+            ...this.history
+        ];
+
+        const response = await axios.post(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
+            model: model,
+            messages: messages,
+            response_format: isLocal ? undefined : { type: "json_object" }
+        }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        return response.data.choices[0].message.content;
+    }
+
+    async _callGemini() {
+        const apiKey = this.config.apiKey || process.env.GEMINI_API_KEY;
+        const model = this.config.geminiModel || DEFAULT_GEMINI_MODEL;
+        const ai = new GoogleGenAI({ apiKey });
+        
+        // Convert history for Gemini
+        const geminiHistory = this.history.slice(0, -1).map(m => ({
+            role: m.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: m.content }]
+        }));
+        
+        const lastMessage = this.history[this.history.length - 1].content;
+
+        const chat = ai.chats.create({
+            model,
+            config: {
+                systemInstruction: this.systemInstruction,
+                responseMimeType: 'application/json'
+            },
+            history: geminiHistory
+        });
+
+        const response = await chat.sendMessage({ message: [{ text: lastMessage }] });
+        return typeof response.text === 'function' ? response.text() : response.text;
     }
-    return {
-        ai: new GoogleGenAI({ apiKey }),
-        model: (config.geminiModel || DEFAULT_GEMINI_MODEL).trim() || DEFAULT_GEMINI_MODEL
-    };
 }
 
 function detectPackageManager(workspaceRoot) {
@@ -327,23 +413,19 @@ async function executeCodeTask(task, options = {}) {
     const requestApproval = typeof options.requestApproval === 'function'
         ? options.requestApproval
         : async () => true;
-    const { ai, model } = getAiClientAndModel();
-
-    const chat = ai.chats.create({
-        model,
-        config: {
-            systemInstruction: CODE_AGENT_PROMPT,
-            responseMimeType: 'application/json'
-        },
-        history: []
-    });
+    const config = readConfig();
+    const provider = options.provider || 'gemini';
+    const client = new UnifiedAgentClient(provider, config);
 
     let observation = await buildInitialObservation(task, workspaceRoot);
 
+    let finalSummary = '';
+    let finalVerification = '';
+    let finalSessionSummary = '';
+
     for (let step = 1; step <= MAX_AGENT_STEPS; step++) {
         onProgress(`Step ${step}: thinking`);
-        const response = await chat.sendMessage({ message: [{ text: observation }] });
-        const text = typeof response.text === 'function' ? response.text() : response.text;
+        const text = await client.sendMessage(observation);
         const decision = extractJson(text);
         const action = decision.action;
         const input = decision.input || {};
@@ -351,17 +433,15 @@ async function executeCodeTask(task, options = {}) {
         onProgress(`Step ${step}: ${action}${input.path ? ` ${input.path}` : input.command ? ` ${input.command}` : ''}`);
 
         if (action === 'finish') {
-            const sessionSummary = input.sessionSummary || input.summary || task;
+            finalSessionSummary = input.sessionSummary || input.summary || task;
+            finalSummary = input.summary || 'Task complete.';
+            finalVerification = input.verification || 'Not specified.';
             writeWorkspaceSession(workspaceRoot, {
-                summary: sessionSummary,
+                summary: finalSessionSummary,
                 lastTask: task,
-                lastVerification: input.verification || 'Not specified.'
+                lastVerification: finalVerification
             });
-            return {
-                summary: input.summary || 'Task complete.',
-                verification: input.verification || 'Not specified.',
-                steps: step
-            };
+            break;
         }
 
         let toolResult = '';
@@ -427,6 +507,39 @@ async function executeCodeTask(task, options = {}) {
         ].join('\n');
     }
 
+    // Check for Agent Collaboration (Review)
+    if (config.enableAgentCollaboration !== false) {
+        const availableProviders = getAvailableProviders(config);
+        const altProviders = availableProviders.filter(p => p !== provider && p !== 'ollama' && p !== 'huggingface');
+        if (altProviders.length > 0 && finalSummary) {
+            const reviewerProvider = altProviders[0];
+            onProgress(`Invoking Reviewer Agent (${reviewerProvider})...`);
+            
+            const reviewerClient = new UnifiedAgentClient(reviewerProvider, config);
+            reviewerClient.systemInstruction = CODE_AGENT_PROMPT + "\n\nYou are the Reviewer Agent. Review the primary agent's changes, test output, and verification. If you spot a critical bug, point it out. Otherwise, confirm it looks good. Return JSON with action: 'finish' and your review in the 'summary' field.";
+            
+            const reviewPrompt = `The primary agent (${provider}) just completed the task: "${task}".\nSummary: ${finalSummary}\nVerification: ${finalVerification}\nGit Status: ${(await getGitContext(workspaceRoot)).status}\n\nPlease review this. Return JSON with action: 'finish'.`;
+            
+            try {
+                const reviewResponse = await reviewerClient.sendMessage(reviewPrompt);
+                const reviewDecision = extractJson(reviewResponse);
+                const reviewInput = reviewDecision.input || {};
+                
+                finalSummary += `\n\n[Review by ${reviewerProvider}]\n${reviewInput.summary || reviewDecision.thought || 'Looks good.'}`;
+            } catch (e) {
+                onProgress(`Reviewer Agent failed: ${e.message}`);
+            }
+        }
+    }
+
+    if (finalSummary) {
+        return {
+            summary: finalSummary,
+            verification: finalVerification,
+            steps: MAX_AGENT_STEPS
+        };
+    }
+
     writeWorkspaceSession(workspaceRoot, {
         summary: `Task stopped before completion: ${task}`,
         lastTask: task,