winter-super-cli 2026.6.23 → 2026.6.26

package/src/cli/repl.js

@@ -22,6 +22,8 @@ import { SessionManager } from '../session/manager.js';
 import { AIProviderManager } from '../ai/providers.js';
 import { ConfigLoader } from './config.js';
 import { PermissionManager } from '../tools/permission.js';
+import { MCPClient } from '../mcp/client.js';
+import { getMcpPreset, upsertMcpServer } from '../mcp/presets.js';
 import { compressConversation } from '../context/compress.js';
 import { getToolUsageSummary } from '../tools/analytics.js';
 import { SweAgent } from '../agent/swe-agent.js';
@@ -1123,6 +1125,19 @@ export class WinterREPL {
         return;
       }
 
+      if (!input.startsWith('/')) {
+        const browserShortcut = this.resolveBrowserShortcut(input);
+        if (browserShortcut) {
+          await this.handleOpenBrowserIntent(input, browserShortcut);
+          return;
+        }
+      }
+
+      if (!input.startsWith('/') && this.isOpenBrowserIntent(input)) {
+        await this.handleOpenBrowserIntent(input);
+        return;
+      }
+
       // Parse @-symbols for non-command input
       if (!input.startsWith('/')) {
         const canUseHeavyContext = await this.shouldUseHeavyProjectContext();
@@ -1196,6 +1211,84 @@ export class WinterREPL {
     }
   }
 
+  isOpenBrowserIntent(input = '') {
+    const raw = String(input || '').trim();
+    if (!raw) return false;
+    const text = `${raw.toLowerCase()}\n${this.normalizeIntentText(raw).toLowerCase()}`;
+    return /\b(mo|open|launch|start)\b.*\b(chrome|browser|trinh duyet|google chrome)\b/i.test(text)
+      || /\b(chrome|browser|trinh duyet|google chrome)\b.*\b(mo|open|launch|start)\b/i.test(text);
+  }
+
+  resolveBrowserShortcut(input = '') {
+    const raw = String(input || '').trim();
+    if (!raw) return null;
+    const normalized = this.normalizeIntentText(raw).toLowerCase();
+    const text = `${raw.toLowerCase()}\n${normalized}`;
+
+    const url = this.extractUrlFromText(raw);
+    if (url && /\b(mo|open|launch|start|browse)\b/i.test(normalized)) {
+      return { url, label: url };
+    }
+
+    const knownSites = [
+      { pattern: /\b(youtube music|yt music|music youtube)\b/i, url: 'https://music.youtube.com', label: 'YouTube Music' },
+      { pattern: /\b(youtube|you tube)\b/i, url: 'https://www.youtube.com', label: 'YouTube' },
+      { pattern: /\b(spotify)\b/i, url: 'https://open.spotify.com', label: 'Spotify' },
+      { pattern: /\b(google)\b/i, url: 'https://www.google.com', label: 'Google' },
+    ];
+
+    if (/\b(mo|open|launch|start)\b/i.test(normalized)) {
+      const site = knownSites.find(item => item.pattern.test(text));
+      if (site) return site;
+    }
+
+    if (/\b(tim|search|kiem)\b/i.test(normalized) && /\b(chrome|google|browser|trinh duyet)\b/i.test(normalized)) {
+      const query = this.extractBrowserSearchQuery(raw);
+      if (query) {
+        return {
+          url: `https://www.google.com/search?${new URLSearchParams({ q: query }).toString()}`,
+          label: `Google search: ${query}`,
+        };
+      }
+    }
+
+    return null;
+  }
+
+  extractBrowserSearchQuery(input = '') {
+    let query = String(input || '').trim();
+    query = query.replace(/^\s*(tìm|tim|search|kiếm|kiem)\s+/i, '');
+    query = query.replace(/\s+(trên|tren|on)\s+(chrome|google|browser|trình duyệt|trinh duyet)\b.*$/i, '');
+    query = query.replace(/\s+(đi|di)\s*$/i, '');
+    query = query.trim();
+    return query || null;
+  }
+
+  extractUrlFromText(input = '') {
+    const match = String(input || '').match(/https?:\/\/[^\s]+/i);
+    return match ? match[0].replace(/[),.;]+$/g, '') : null;
+  }
+
+  async handleOpenBrowserIntent(input = '', options = {}) {
+    const url = options.url || this.extractUrlFromText(input) || 'about:blank';
+    const result = await this.tools.execute('OpenBrowser', { browser: 'chrome', url }, { cwd: this.projectPath });
+    await this.session?.addToHistory?.({ role: 'user', content: input });
+
+    if (result?.success === false) {
+      const message = `Không mở được Chrome: ${result.error || 'unknown error'}`;
+      console.log(`${colors.red}${message}${colors.reset}`);
+      if (result.recovery) console.log(`${colors.dim}${result.recovery}${colors.reset}`);
+      await this.session?.addToHistory?.({ role: 'assistant', content: message });
+      return result;
+    }
+
+    const label = options.label || url;
+    const message = `Đã mở Chrome${url && url !== 'about:blank' ? `: ${label}` : '.'}`;
+    console.log(`${colors.green}${message}${colors.reset}`);
+    await this.session?.addToHistory?.({ role: 'assistant', content: message });
+    return result;
+  }
+
   showSmartTip(input = '') {
     const text = input.toLowerCase();
     let tip = null;
@@ -1395,7 +1488,7 @@ export class WinterREPL {
 
 CRITICAL DEBUG/AGENT RULES:
 1. Inspect the project before changing anything. Read the failing file, related caller, config, and logs.
-2. Reproduce or locate the first hard failure. For frontend/runtime UI issues, use BrowserDebug when a URL/dev server is available.
+2. Reproduce or locate the first hard failure. For frontend/runtime UI issues, use chrome-devtools MCP in visible Chrome when a URL/dev server is available; use BrowserDebug only as a headless fallback.
 3. Patch the smallest root cause with Write/Edit.
 4. Run the closest verification command(s): ${verifyCommands.join(' && ')}.
 5. If verification fails, read the new error, patch again, and run verification again.
@@ -1651,14 +1744,14 @@ ${colors.reset}
       case 'review':
         return byName(['Read', 'Grep', 'Glob', 'Bash', 'WebFetch']);
       case 'debug':
-        return byName(['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'BrowserDebug', 'WebFetch', 'Parallel']);
+        return byName(['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'OpenBrowser', 'BrowserDebug', 'WebFetch', 'MCP', 'Parallel']);
       case 'research':
         return byName(['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'Parallel']);
       case 'design':
       case 'ui':
-        return byName(['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'BrowserDebug', 'WebFetch']);
+        return byName(['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'OpenBrowser', 'BrowserDebug', 'WebFetch', 'MCP']);
       default:
-        return byName(['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'BrowserDebug', 'WebFetch', 'WebSearch', 'Parallel', 'Agent']);
+        return byName(['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'OpenBrowser', 'BrowserDebug', 'WebFetch', 'WebSearch', 'MCP', 'Parallel', 'Agent']);
     }
   }
 
@@ -1761,8 +1854,18 @@ ${colors.reset}
     return '';
   }
 
+  normalizeIntentText(text = '') {
+    return String(text || '')
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .replace(/đ/g, 'd')
+      .replace(/Đ/g, 'D')
+      .toLowerCase();
+  }
+
   actionRequiresTools(messages = []) {
-    const text = this.getLatestUserText(messages).toLowerCase();
+    const rawText = this.getLatestUserText(messages).toLowerCase();
+    const text = `${rawText}\n${this.normalizeIntentText(rawText)}`;
     if (!text.trim()) return false;
 
     // Direct action verbs (EN + VN)
@@ -1773,6 +1876,8 @@ ${colors.reset}
     const pureQuestionPattern = /^(what|why|how|when|where|is|are|can|could|should|would|explain|describe|tell me|compare|giải thích|mô tả|so sánh|tai sao|vi sao|la gi|co nen|co phai|tại sao|vì sao|là gì|có nên|có phải|nhu the nao|như thế nào|khi nào)\b/i;
 
     if (pureQuestionPattern.test(text) && !actionPattern.test(text)) return false;
+
+    if (this.isBrowserInteractionRequest(rawText)) return true;
     
     // Even without explicit target, some verbs are strong enough on their own
     const strongActionAlone = /\b(fix|debug|deploy|build|test|commit|install|run|refactor|sửa|chạy|cài|triển khai|xây dựng)\b/i;
@@ -1802,6 +1907,15 @@ ${colors.reset}
     return true;
   }
 
+  isBrowserInteractionRequest(text = '') {
+    const raw = String(text || '');
+    const normalized = this.normalizeIntentText(raw);
+    const combined = `${raw}\n${normalized}`;
+    const action = /\b(click|fill|submit|press|select|navigate|bam|dien|chon|nhan|vao|bấm|điền|chọn|nhấn|vào)\b/i;
+    const target = /\b(url|http|https|site|website|web|page|form|button|link|chrome|browser|trang|nut|nút|dang ky|dang nhap|khach hang|khách hàng|đăng ký|đăng nhập)\b/i;
+    return action.test(combined) && target.test(combined);
+  }
+
   detectFakeCompletion(content = '') {
     const text = String(content || '').toLowerCase();
     if (!text.trim()) return false;
@@ -1810,6 +1924,9 @@ ${colors.reset}
     const fakeCompletionClaims = /(?:đã (?:sửa|tạo|viết|xóa|cập nhật|thêm|chỉnh|xong|hoàn thành|fix|update|edit|write|create|delete|remove|modify|change|apply|deploy|push)|i(?:'ve| have) (?:fixed|created|written|updated|added|modified|changed|edited|applied|deployed|deleted|removed|patched|implemented|refactored)|done!|xong rồi|hoàn thành|đã hoàn tất|hoàn tất|the (?:fix|change|update|edit|modification) (?:has been|is) (?:applied|done|completed|made)|here(?:'s| is) the (?:fix|update|change|solution|implementation|code)|file (?:has been|was) (?:updated|created|modified|written|changed)|changes? (?:have been|has been|were) (?:made|applied|saved)|successfully (?:updated|created|modified|fixed|applied|changed|written))/i;
     if (fakeCompletionClaims.test(text)) return true;
 
+    const fakeBrowserClaims = /(?:đã|da|i(?:'ve| have))\s+(?:bấm|bam|click(?:ed)?|mở|mo|open(?:ed)?|điền|dien|fill(?:ed)?|chọn|chon|select(?:ed)?|submit(?:ted)?|vào|vao|navigate(?:d)?)/i;
+    if (fakeBrowserClaims.test(text)) return true;
+
     // Detect code blocks that pretend to show "changes" without tool use
     const codeBlockWithFilePath = /```[\s\S]*?(?:[\/\\][\w.-]+\.(?:js|ts|py|css|html|json|md|jsx|tsx|vue|go|rs|java|c|cpp|rb|sh))[\s\S]*?```/i;
     const claimsFileChange = /(?:here(?:'s| is)|below|sau đây|dưới đây|như sau|updated|modified|changed|new|fixed)/i;
@@ -1820,6 +1937,19 @@ ${colors.reset}
 
   buildToolEvidenceCorrection(messages = []) {
     const request = this.getLatestUserText(messages);
+    if (this.isBrowserInteractionRequest(request)) {
+      return [
+        'RUNTIME ENFORCEMENT: Your previous response was BLOCKED because you claimed a browser/web action without real browser tool evidence.',
+        '',
+        'For browser interaction tasks you MUST use tools, not prose:',
+        '1. If chrome-devtools MCP is configured, call MCP {"server":"chrome-devtools","tool":"list"} first if needed.',
+        '2. Use chrome-devtools MCP tools such as new_page/navigate_page, take_snapshot, click, fill/fill_form, evaluate_script, list_network_requests, and take_screenshot in visible Chrome.',
+        '3. Use WebFetch only for static text extraction. WebFetch cannot click buttons, fill forms, or preserve page state. BrowserDebug is headless and should be fallback only.',
+        '4. Do not say "đã bấm", "đã điền", "đã mở", or "đã kiểm tra" until a browser/MCP tool result proves it.',
+        '',
+        `Original user request: ${request}`,
+      ].join('\n');
+    }
     return [
       '⚠️ RUNTIME ENFORCEMENT: Your previous response was BLOCKED because you did not use any tool.',
       '',
@@ -1832,7 +1962,7 @@ ${colors.reset}
       'DO NOT say "I have updated/created/fixed" without a tool call proving it.',
       'DO NOT describe what you would do. Actually DO IT with tool calls.',
       '',
-      'Available tools: Read, Write, Edit, Bash, Glob, Grep, BrowserDebug, WebFetch, WebSearch.',
+      'Available tools: Read, Write, Edit, Bash, Glob, Grep, OpenBrowser, BrowserDebug, WebFetch, WebSearch, MCP.',
       '',
       'If native tool calls are not supported, output exactly one fallback tool call:',
       '<invoke name="Read"><parameter name="path">README.md</parameter></invoke>',
@@ -1848,11 +1978,16 @@ ${colors.reset}
    * Giúp model yếu/nhỏ chọn đúng tool thay vì dùng Bash cho mọi thứ.
    */
   buildToolRoutingHint(userMessage = '') {
-    const text = String(userMessage || '').toLowerCase();
+    const rawText = String(userMessage || '').toLowerCase();
+    const text = `${rawText}\n${this.normalizeIntentText(rawText)}`;
     if (!text.trim()) return null;
 
     const hints = [];
 
+    if (/\b(click|fill|submit|press|select|navigate|bam|dien|chon|nhan|vao|bấm|điền|chọn|nhấn|vào)\b/i.test(text) && /\b(web|website|page|url|http|chrome|browser|form|button|link|trang|nut|nút|dang ky|dang nhap|khach hang|đăng ký|đăng nhập|khách hàng)\b/i.test(text)) {
+      hints.push('TOOL HINT: This is a live browser interaction. Do NOT use WebFetch alone. Prefer visible Chrome via MCP {"server":"chrome-devtools","tool":"list"} then chrome-devtools tools new_page/navigate_page, take_snapshot, click, fill/fill_form, evaluate_script, list_network_requests, and take_screenshot. Only use BrowserDebug as headless fallback. Only claim click/fill/navigation after MCP or BrowserDebug evidence.');
+    }
+
     // Detect file reading requests
     const hasPath = /[A-Za-z]:[\\/][\w.\\/\\-]+/i.test(text) || /(?:^|\s)[.~]?\/[\w.\/-]+/i.test(text);
     const readVerbs = /\b(đọc|doc|read|xem|view|mở|open|show|hiện|hiển thị|cat|type)\b/i;
@@ -1891,7 +2026,11 @@ ${colors.reset}
 
     // Detect URL/web requests  
     if (/\b(https?:\/\/[^\s]+|url|website|trang web|web page)\b/i.test(text)) {
-      hints.push('TOOL HINT: To fetch a URL, call tool WebFetch with {"url": "<url>"}. For browser debugging, use BrowserDebug.');
+      hints.push('TOOL HINT: To fetch static URL text, call WebFetch. For live visible browser debugging/control, prefer MCP server chrome-devtools with new_page/navigate_page, take_snapshot, click, fill/fill_form, evaluate_script, list_console_messages, list_network_requests, or performance trace tools; use BrowserDebug only as headless fallback.');
+    }
+
+    if (/\b(chrome|devtools|browser debug|debug browser|screenshot|console|network|lcp|performance|perf|web vitals|localhost|127\.0\.0\.1)\b/i.test(text)) {
+      hints.push('TOOL HINT: For "open Chrome" / "mở chrome", call OpenBrowser {"browser":"chrome","url":"about:blank"}. Do NOT call Bash/Get-Command/Start-Process. If configured, use MCP {"server":"chrome-devtools","tool":"list"} for page state, console, network, screenshots, and performance.');
     }
 
     if (hints.length === 0) return null;
@@ -2233,6 +2372,9 @@ ${colors.reset}
 
   async requestFinalAnswer(messages, toolSummaries, startedAt, totalUsage) {
     const executionProfile = this.selectExecutionProfile(messages, { enableTools: false });
+    const latestUserText = this.getLatestUserText(messages);
+    const browserInteraction = this.isBrowserInteractionRequest(latestUserText);
+    const hasBrowserEvidence = toolSummaries.some(summary => /^(MCP|BrowserDebug|OpenBrowser):/i.test(summary));
     const finalMessages = [
       ...messages,
       {
@@ -2241,7 +2383,11 @@ ${colors.reset}
           'You have finished using tools.',
           'Now answer the user directly in the same language as the user.',
           'Do not call more tools. Do not ask the user to provide files you already read.',
-          'Use the tool results above. If a tool failed, explain the concrete failure briefly and answer with the available evidence.',
+          'Use only the tool results above as evidence for claims about files, commands, tests, and changes.',
+          'Start with the actual outcome, then mention only the most relevant files/commands. Avoid broad generic advice.',
+          'If a tool failed, explain the concrete failure briefly and answer with the available evidence.',
+          'Do not repeat the plan. Do not re-summarize unrelated project context. Do not claim memory/tool state that is not visible in the transcript.',
+          browserInteraction && !hasBrowserEvidence ? 'Important: The user asked for browser interaction, but no MCP/BrowserDebug/OpenBrowser result is available. You must say the browser action was NOT performed; do not claim you clicked, filled, navigated, or inspected pages.' : '',
           toolSummaries.length ? `Tool summary:\n${toolSummaries.join('\n')}` : '',
         ].filter(Boolean).join('\n'),
       },
@@ -2254,7 +2400,7 @@ ${colors.reset}
       }
 
       if (typeof this.ai.streamRequest === 'function') {
-        return await this.streamFinalAnswer(finalMessages, startedAt, totalUsage, executionProfile);
+        return await this.streamFinalAnswer(finalMessages, startedAt, totalUsage, executionProfile, { browserInteraction, hasBrowserEvidence });
       }
 
       const response = await this.ai.sendRequest(finalMessages, {
@@ -2264,7 +2410,10 @@ ${colors.reset}
         signal: this.currentAbortController?.signal,
       });
       this.addUsage(totalUsage, response.usage);
-      const content = response.choices?.[0]?.message?.content || '';
+      let content = response.choices?.[0]?.message?.content || '';
+      if (browserInteraction && !hasBrowserEvidence && this.detectFakeCompletion(content)) {
+        content = 'Chưa thực hiện được thao tác trên trình duyệt: lượt này không có bằng chứng từ MCP/BrowserDebug/OpenBrowser, nên Winter chặn câu trả lời để tránh báo sai. Hãy bật chrome-devtools MCP hoặc dùng lại yêu cầu để Winter gọi đúng browser tool.';
+      }
       
       if (this.spinner) this.spinner.stop();
       
@@ -2281,7 +2430,7 @@ ${colors.reset}
     }
   }
 
-  async streamFinalAnswer(messages, startedAt, totalUsage, executionProfile = null) {
+  async streamFinalAnswer(messages, startedAt, totalUsage, executionProfile = null, validation = {}) {
     let content = '';
     const profile = executionProfile || this.selectExecutionProfile(messages, { enableTools: false });
 
@@ -2307,6 +2456,10 @@ ${colors.reset}
 
       if (this.spinner) this.spinner.stop();
 
+      if (validation.browserInteraction && !validation.hasBrowserEvidence && this.detectFakeCompletion(content)) {
+        content = 'Chưa thực hiện được thao tác trên trình duyệt: lượt này không có bằng chứng từ MCP/BrowserDebug/OpenBrowser, nên Winter chặn câu trả lời để tránh báo sai. Hãy bật chrome-devtools MCP hoặc dùng lại yêu cầu để Winter gọi đúng browser tool.';
+      }
+
       if (content) {
         this.printAssistantAnswer(content, startedAt, totalUsage);
         return content;
@@ -2327,6 +2480,9 @@ ${colors.reset}
     });
     this.addUsage(totalUsage, response.usage);
     content = response.choices?.[0]?.message?.content || '';
+    if (validation.browserInteraction && !validation.hasBrowserEvidence && this.detectFakeCompletion(content)) {
+      content = 'Chưa thực hiện được thao tác trên trình duyệt: lượt này không có bằng chứng từ MCP/BrowserDebug/OpenBrowser, nên Winter chặn câu trả lời để tránh báo sai. Hãy bật chrome-devtools MCP hoặc dùng lại yêu cầu để Winter gọi đúng browser tool.';
+    }
     if (content) {
       this.printAssistantAnswer(content, startedAt, totalUsage);
     }
@@ -2495,6 +2651,44 @@ ${colors.reset}
     };
   }
 
+  async updateRecentWorkLedger({ userMessage = '', finalContent = '', toolCalls = [], usedTools = false, usedMutatingTools = false } = {}) {
+    if (typeof this.session?.replaceMemory !== 'function') return;
+
+    const toolLines = Array.isArray(toolCalls) && toolCalls.length > 0
+      ? toolCalls.slice(-8).map(call => `- ${this.summarizeToolCallForLedger(call)}`).join('\n')
+      : '- none';
+    const status = usedMutatingTools ? 'changed project state' : (usedTools ? 'inspected project state' : 'answered without tools');
+    const final = this.compactText(String(finalContent || '').replace(/\s+/g, ' ').trim(), 700, 'final answer');
+    const request = this.compactText(String(userMessage || '').replace(/\s+/g, ' ').trim(), 400, 'user request');
+    const content = [
+      `Updated: ${new Date().toISOString()}`,
+      `Status: ${status}`,
+      `Last user request: ${request || '(empty)'}`,
+      'Tool evidence from last turn:',
+      toolLines,
+      final ? `Last answer summary: ${final}` : 'Last answer summary: (empty)',
+      '',
+      'Instruction for next turn: treat this ledger as the source of truth for what Winter already did. Do not repeat completed inspection unless the user asks or new evidence is needed.',
+    ].join('\n');
+
+    await this.session.replaceMemory('[Recent Work Ledger]', content, 'summary');
+  }
+
+  summarizeToolCallForLedger(call = {}) {
+    const fn = call.function || {};
+    const name = this.tools?.normalizeToolName?.(fn.name || call.name || call.toolName || 'unknown') || fn.name || call.name || call.toolName || 'unknown';
+    let args = {};
+    try {
+      args = typeof fn.arguments === 'string' ? JSON.parse(fn.arguments || '{}') : (call.toolArgs || fn.arguments || {});
+    } catch {
+      args = call.toolArgs || {};
+    }
+    const target = args.file_path || args.path || args.cwd || args.url || args.server || args.pattern || '';
+    const command = args.command || args.cmd || '';
+    const detail = command || target || '';
+    return detail ? `${name}: ${this.compactText(String(detail), 180, `${name} args`)}` : name;
+  }
+
   async compressSessionContext(verbose = false) {
     const raw = this.session.getHistory(80)
       .filter(entry => entry && typeof entry.content === 'string')
@@ -2711,6 +2905,13 @@ ${colors.reset}
         historyEntry.tool_calls = allToolCalls;
       }
       await this.session.addToHistory(historyEntry);
+      await this.updateRecentWorkLedger({
+        userMessage: message,
+        finalContent,
+        toolCalls: allToolCalls,
+        usedTools: allToolCalls.length > 0,
+        usedMutatingTools,
+      });
 
       // Tự động verify: nếu AI đã dùng tools (sửa code), chạy test/build.
       if (finalContent && this.shouldAutoVerifyAfterTools(message, usedMutatingTools)) {
@@ -3319,6 +3520,8 @@ Light mode enabled for safety. Heavy codebase, graph, and git context are skippe
     const [action, ...rest] = args;
     const config = await this.config.load();
     config.mcp = config.mcp || { servers: [] };
+    config.permissions = config.permissions || { allowlist: {} };
+    config.permissions.allowlist = config.permissions.allowlist || { tools: [], commands: [], mcpServers: [] };
 
     switch (action) {
       case undefined:
@@ -3351,10 +3554,33 @@ Light mode enabled for safety. Heavy codebase, graph, and git context are skippe
         }
         config.mcp.servers = (config.mcp.servers || []).filter(server => server.name !== name);
         config.mcp.servers.push({ name, command, args: parsedArgs, enabled: true });
+        config.permissions.allowlist.mcpServers = [...new Set([...(config.permissions.allowlist.mcpServers || []), name])];
         await this.config.save(config);
         console.log(`${colors.green}✓ Added MCP server: ${name}${colors.reset}`);
         break;
       }
+      case 'preset':
+      case 'install': {
+        const [presetName, ...presetOptions] = rest;
+        if (!presetName) {
+          console.log(`${colors.yellow}Usage: /mcp preset <chrome-devtools> [--isolated] [--headless] [--browser-url <url>]${colors.reset}`);
+          break;
+        }
+        try {
+          const server = getMcpPreset(presetName, presetOptions);
+          upsertMcpServer(config, server);
+          await this.config.save(config);
+          console.log(`${colors.green}OK Installed MCP preset: ${server.name}${colors.reset}`);
+          console.log(`  ${colors.dim}${server.command} ${server.args.join(' ')}${colors.reset}`);
+          if (!server.args.includes('--headless')) {
+            console.log(`  ${colors.dim}Visible Chrome mode: enabled. Use --headless only for background browser runs.${colors.reset}`);
+          }
+          console.log(`  ${colors.dim}Inspect tools with: /mcp tools ${server.name}${colors.reset}`);
+        } catch (error) {
+          console.log(`${colors.red}${error.message}${colors.reset}`);
+        }
+        break;
+      }
       case 'remove': {
         const name = rest[0];
         if (!name) {
@@ -3362,6 +3588,7 @@ Light mode enabled for safety. Heavy codebase, graph, and git context are skippe
           break;
         }
         config.mcp.servers = (config.mcp.servers || []).filter(server => server.name !== name);
+        config.permissions.allowlist.mcpServers = (config.permissions.allowlist.mcpServers || []).filter(server => server !== name);
         await this.config.save(config);
         console.log(`${colors.green}✓ Removed MCP server: ${name}${colors.reset}`);
         break;
@@ -3376,8 +3603,37 @@ Light mode enabled for safety. Heavy codebase, graph, and git context are skippe
         console.log(`${colors.green}✓ MCP server allowed: ${name}${colors.reset}`);
         break;
       }
+      case 'tools': {
+        const name = rest[0];
+        if (!name) {
+          console.log(`${colors.yellow}Usage: /mcp tools <name>${colors.reset}`);
+          break;
+        }
+        const server = (config.mcp.servers || []).find(item => item.name === name && item.enabled !== false);
+        if (!server) {
+          console.log(`${colors.red}MCP server not configured or disabled: ${name}${colors.reset}`);
+          break;
+        }
+        const client = new MCPClient(server);
+        try {
+          const tools = await client.listTools();
+          console.log(`${colors.cyan}MCP Tools: ${name}${colors.reset}`);
+          if (!tools.length) {
+            console.log(`  ${colors.dim}No tools reported.${colors.reset}`);
+          }
+          tools.forEach(tool => {
+            const description = tool.description ? ` - ${tool.description}` : '';
+            console.log(`  ${colors.green}${tool.name}${colors.reset}${description}`);
+          });
+        } catch (error) {
+          console.log(`${colors.red}Failed to list MCP tools: ${error.message}${colors.reset}`);
+        } finally {
+          await client.close();
+        }
+        break;
+      }
       default:
-        console.log(`${colors.yellow}Usage: /mcp <list|add|remove|allow>${colors.reset}`);
+        console.log(`${colors.yellow}Usage: /mcp <list|add|preset|install|remove|allow|tools>${colors.reset}`);
     }
   }
 

package/src/cli/slash-commands.js

@@ -1,6 +1,7 @@
 export const SLASH_COMMANDS = [
   { cmd: '/project', desc: 'Show/set current project' },
   { cmd: '/index', desc: 'Index codebase for semantic search', usage: '/index [full]' },
+  { cmd: '/rag', desc: 'RAG query and index management', sub: ['query', 'index', 'status', 'search'] },
   { cmd: '/search', desc: 'Semantic codebase search', usage: '/search <query>' },
   { cmd: '/search-def', desc: 'Find symbol/definition in codebase', usage: '/search-def <name>' },
   { cmd: '/undo', desc: 'Undo last change from backup', usage: '/undo [file]' },
@@ -40,7 +41,7 @@ export const SLASH_COMMANDS = [
   { cmd: '/skill', desc: 'Skills management', sub: ['list', 'enable', 'create'] },
   { cmd: '/skills', desc: 'List local Winter/Codex/Claude skills' },
   { cmd: '/plugin', desc: 'Plugin management', sub: ['list', 'install', 'remove'] },
-  { cmd: '/mcp', desc: 'MCP server management', sub: ['list', 'add', 'remove', 'allow'] },
+  { cmd: '/mcp', desc: 'MCP server management', sub: ['list', 'add', 'preset', 'install', 'remove', 'allow', 'tools'] },
   { cmd: '/permissions', desc: 'Permission allowlist', sub: ['list', 'allow', 'prompt'] },
   { cmd: '/stats', desc: 'Tool usage statistics' },
   { cmd: '/replay', desc: 'Replay recent session/tool events', usage: '/replay [count]' },

package/src/mcp/client.js

@@ -22,12 +22,14 @@ export class MCPClient {
       throw new Error('MCP server command is required');
     }
 
-    const args = Array.isArray(this.serverConfig.args) ? this.serverConfig.args : [];
-    this.process = spawn(command, args, {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      shell: false,
-      windowsHide: true,
-    });
+    const args = Array.isArray(this.serverConfig.args) ? this.serverConfig.args : [];
+    this.process = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: this.serverConfig.cwd || undefined,
+      env: { ...process.env, ...(this.serverConfig.env || {}) },
+      shell: false,
+      windowsHide: true,
+    });
 
     this.process.stdout.on('data', chunk => this.handleStdout(chunk));
     this.process.stderr.on('data', chunk => {

package/src/mcp/ide-server.js

@@ -6,7 +6,10 @@
 import { createServer } from 'net';
 import { promises as fs } from 'fs';
 import path from 'path';
-import { MCPProtocol } from './protocol.js';
+import { CompletionProvider } from './completions.js';
+import { ConfigLoader } from '../cli/config.js';
+import { AIProviderManager } from '../ai/providers.js';
+import { extractTextFromResponse } from '../ai/provider-adapters.js';
 
 const SERVER_NAME = 'winter-ide';
 const SERVER_VERSION = '1.0.0';
@@ -16,10 +19,13 @@ export class IDEServer {
     this.port = options.port || 4157;
     this.host = options.host || '127.0.0.1';
     this.projectPath = options.projectPath || process.cwd();
-    this.protocol = new MCPProtocol();
     this.server = null;
     this.clients = new Map();
     this.handlers = new Map();
+    this.completionProvider = new CompletionProvider();
+    this.config = options.config || new ConfigLoader();
+    this.ai = options.ai || new AIProviderManager(this.config);
+    this.aiReady = false;
     this._registerDefaultHandlers();
   }
 
@@ -162,6 +168,73 @@ export class IDEServer {
     this.handlers.set('ping', (clientId) => {
       this._sendTo(clientId, { type: 'pong', timestamp: Date.now() });
     });
+
+    this.handlers.set('inline:complete', async (clientId, msg) => {
+      try {
+        const filePath = msg.path || msg.filePath;
+        if (!filePath) {
+          this._sendTo(clientId, { type: 'error', message: 'inline:complete requires path' });
+          return;
+        }
+
+        const fullPath = path.isAbsolute(filePath) ? filePath : path.resolve(this.projectPath, filePath);
+        const content = await fs.readFile(fullPath, 'utf8');
+        const lines = content.split(/\r?\n/);
+        const line = Number.isFinite(Number(msg.line)) ? Math.max(1, Number(msg.line)) : lines.length;
+        const column = Number.isFinite(Number(msg.column)) ? Math.max(0, Number(msg.column)) : (lines[line - 1] || '').length;
+
+        const result = await this.completionProvider.generate({
+          filePath: fullPath,
+          content,
+          cursorLine: Math.min(line - 1, Math.max(0, lines.length - 1)),
+          cursorColumn: column,
+          language: detectLanguage(fullPath),
+        });
+        this._sendTo(clientId, { type: 'inline:complete:result', ...result });
+      } catch (error) {
+        this._sendTo(clientId, { type: 'error', message: `Inline completion failed: ${error.message}` });
+      }
+    });
+
+    this.handlers.set('ai:action', async (clientId, msg) => {
+      try {
+        const action = String(msg.action || 'explain').toLowerCase();
+        const code = String(msg.code || '');
+        if (!code.trim()) {
+          this._sendTo(clientId, { type: 'error', message: 'ai:action requires code' });
+          return;
+        }
+
+        await this._ensureAi();
+        const prompt = buildActionPrompt(action, code, msg.filePath || msg.path);
+        const data = await this.ai.sendRequest([
+          { role: 'system', content: 'You are Winter IDE assistant. Be concise, practical, and return code only when asked to fix, refactor, or generate tests.' },
+          { role: 'user', content: prompt },
+        ], { reason: `ide:${action}` });
+
+        const response = extractTextFromResponse(data);
+        const payload = {
+          type: 'ai:action:result',
+          action,
+          response,
+        };
+
+        if (['fix', 'refactor', 'generate-tests'].includes(action)) {
+          const editedContent = extractCodeBlock(response);
+          if (editedContent) payload.editedContent = editedContent;
+        }
+
+        this._sendTo(clientId, payload);
+      } catch (error) {
+        this._sendTo(clientId, { type: 'error', message: `AI action failed: ${error.message}` });
+      }
+    });
+  }
+
+  async _ensureAi() {
+    if (this.aiReady) return;
+    await this.ai.init();
+    this.aiReady = true;
   }
 
   async _handleMessage(clientId, raw) {
@@ -192,4 +265,43 @@ export class IDEServer {
   }
 }
 
+function detectLanguage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const map = {
+    '.js': 'javascript',
+    '.jsx': 'javascriptreact',
+    '.ts': 'typescript',
+    '.tsx': 'typescriptreact',
+    '.py': 'python',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.java': 'java',
+    '.cs': 'csharp',
+    '.cpp': 'cpp',
+    '.c': 'c',
+    '.h': 'c',
+    '.hpp': 'cpp',
+    '.json': 'json',
+    '.md': 'markdown',
+  };
+  return map[ext] || ext.replace(/^\./, '') || 'text';
+}
+
+function buildActionPrompt(action, code, filePath = '') {
+  const location = filePath ? `File: ${filePath}\n\n` : '';
+  const prompts = {
+    explain: 'Explain what this code does and point out notable risks.',
+    refactor: 'Refactor this code. Return the improved code in one fenced code block, followed by a brief note.',
+    fix: 'Find and fix bugs in this code. Return the fixed code in one fenced code block, followed by a brief note.',
+    review: 'Review this code for bugs, risks, and missing tests. Prioritize findings.',
+    'generate-tests': 'Generate practical tests for this file. Return the test code in one fenced code block.',
+  };
+  return `${location}${prompts[action] || prompts.explain}\n\nCode:\n\`\`\`\n${code}\n\`\`\``;
+}
+
+function extractCodeBlock(text = '') {
+  const match = String(text).match(/```(?:[\w-]+)?\r?\n([\s\S]*?)```/);
+  return match ? match[1].trimEnd() : '';
+}
+
 export default IDEServer;