winter-super-cli 2026.6.24 → 2026.6.26

package/README.md

@@ -162,6 +162,25 @@ Winter reads config from the user profile directory. Typical settings include:
 - MCP servers
 - sandbox / allowlist options
 
+### Chrome DevTools MCP
+
+Winter has a built-in preset for ChromeDevTools/chrome-devtools-mcp:
+
+```bash
+winter mcp preset chrome-devtools --isolated
+winter mcp tools chrome-devtools
+```
+
+In the REPL, use the same flow with slash commands:
+
+```text
+/mcp preset chrome-devtools --isolated
+/mcp tools chrome-devtools
+```
+
+The preset registers the `chrome-devtools` MCP server, allowlists it, and gives Winter runtime hints to use its page navigation, click, fill, snapshot, screenshot, console, network, and performance tools for live browser debugging. Omit `--headless` when you want to watch Winter operate Chrome in a normal visible window.
+It requires Node.js 22.12+ and a current Chrome installation, matching the upstream MCP package requirements.
+
 ### Minimal example
 
 ```json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "winter-super-cli",
-  "version": "2026.6.24",
+  "version": "2026.6.26",
   "description": "❄️ AI-Powered Development CLI with Interactive REPL",
   "type": "module",
   "main": "bin/winter.js",

package/src/agent/agent-definitions.js

@@ -3,13 +3,13 @@ import { pathToFileURL } from 'url';
 import { promises as fs } from 'fs';
 
 const DEFAULT_TOOL_SETS = {
-  general: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'BrowserDebug', 'WebFetch', 'WebSearch', 'Parallel', 'Agent'],
+  general: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'OpenBrowser', 'BrowserDebug', 'WebFetch', 'WebSearch', 'Parallel', 'Agent'],
   plan: ['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'Parallel'],
   review: ['Read', 'Grep', 'Glob', 'Bash', 'WebFetch'],
-  debug: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'BrowserDebug', 'WebFetch', 'Parallel'],
-  design: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'BrowserDebug', 'WebFetch'],
+  debug: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'OpenBrowser', 'BrowserDebug', 'WebFetch', 'Parallel'],
+  design: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'OpenBrowser', 'BrowserDebug', 'WebFetch'],
   research: ['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'Parallel'],
-  swe: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'BrowserDebug', 'Parallel'],
+  swe: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'OpenBrowser', 'BrowserDebug', 'Parallel'],
 };
 
 const BUILTIN_AGENTS = [

package/src/ai/prompts/system-prompt.js

@@ -100,7 +100,9 @@ function buildStandardSystemPrompt(options = {}) {
     'Use tools when they materially improve correctness. Inspect before editing. Verify after changes.',
     'Use maximum reasoning discipline for every model tier, including tiny, local, free, and routed models.',
     'Never invent file paths, APIs, command output, or test results.',
+    'For visible browser launch requests such as "mở chrome" or "open Chrome", use OpenBrowser; do not use Bash, Get-Command, Start-Process, or shell launch commands.',
     'For debug work, locate the first hard failure, patch the root cause, and verify with the closest test/build/browser smoke.',
+    'For live browser debugging and user-visible Chrome control, prefer MCP server chrome-devtools when configured; use its page, click, fill, snapshot, screenshot, console, network, and performance tools before falling back to headless browser automation.',
     'For design/UI work, inspect the existing interface and design resources first; avoid generic placeholder layouts.',
     'If the user attaches or pastes an image, analyze it as primary evidence.',
     '',

package/src/cli/commands.js

@@ -10,6 +10,7 @@ import { DesignCommands } from '../design/commands.js';
 import { SkillManager } from '../skills/manager.js';
 import { PluginManager } from '../plugins/manager.js';
 import { MCPClient } from '../mcp/client.js';
+import { getMcpPreset, upsertMcpServer } from '../mcp/presets.js';
 import { BenchmarkRunner } from '../ai/benchmark.js';
 import { redactSecrets } from './secret-env.js';
 import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from './runtime-env.js';
@@ -813,6 +814,29 @@ EXECUTION CONTRACT:
         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: winter 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: winter 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) {
@@ -868,7 +892,7 @@ EXECUTION CONTRACT:
         break;
       }
       default:
-        console.log(`${colors.yellow}Usage: winter mcp <list|add|remove|allow|tools>${colors.reset}`);
+        console.log(`${colors.yellow}Usage: winter mcp <list|add|preset|install|remove|allow|tools>${colors.reset}`);
     }
   }
 

package/src/cli/config.js

@@ -7,6 +7,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { homedir } from 'os';
 import { loadEnvFile, stripInlineSecrets } from './secret-env.js';
+import { CHROME_DEVTOOLS_MCP_NAME, createChromeDevtoolsMcpServer } from '../mcp/presets.js';
 
 export class ConfigLoader {
   constructor() {
@@ -61,13 +62,13 @@ export class ConfigLoader {
       permissions: {
         promptByDefault: true,
         allowlist: {
-          tools: ['Read', 'Glob', 'Grep', 'LSP', 'TaskCreate', 'TaskUpdate', 'TaskList', 'WebFetch', 'WebSearch', 'Parallel'],
+          tools: ['Read', 'Glob', 'Grep', 'LSP', 'TaskCreate', 'TaskUpdate', 'TaskList', 'WebFetch', 'WebSearch', 'Parallel', 'MCP'],
           commands: [],
-          mcpServers: [],
+          mcpServers: [CHROME_DEVTOOLS_MCP_NAME],
         },
       },
       mcp: {
-        servers: [],
+        servers: [createChromeDevtoolsMcpServer(['--isolated'])],
       },
       routing: {
         strategy: 'heuristic',

package/src/cli/prompt-builder.js

@@ -117,12 +117,14 @@ export class PromptBuilder {
       `Prefer Read/Grep/Glob before editing. Use Write/Edit for file changes.`,
       `CRITICAL: When the user asks you to fix/create/edit/run/modify anything, you MUST call tools (Read, Write, Edit, Bash, etc.) to actually do it. NEVER just write code in a markdown code block and claim it is done. Winter will detect and block fake completions. If you say "đã sửa/đã tạo/done/fixed" without a tool call, your response will be rejected.`,
       `Tool call compatibility: if native tool calls are unavailable, output exactly one of these forms and no prose: <invoke name="Read"><parameter name="path">README.md</parameter></invoke> OR {"tool":"Read","arguments":{"path":"README.md"}} OR CALL_TOOL Read {"path":"README.md"}.`,
-      `Browser capability: You CAN browse URLs! Use WebFetch to fetch page content (text extraction) or BrowserDebug for Chrome automation (JS rendering, screenshots). If user shares a URL or asks to view a website, use these tools automatically.`,
+      `Open browser requests: if the user asks to "mở chrome", "open Chrome", or open a URL in a visible browser, use OpenBrowser. Do NOT use Bash, Get-Command, Start-Process, cmd start, or shell app launch commands for this.`,
+      `Browser capability: You CAN browse URLs! Use WebFetch only for static page text extraction. For live Chrome debugging and visible browser control, prefer MCP server "chrome-devtools" when configured: use MCP tool "new_page" or "navigate_page", then "take_snapshot", "click", "fill"/"fill_form", "take_screenshot", "evaluate_script", "list_console_messages", "list_network_requests", or performance trace tools. BrowserDebug is headless fallback only when chrome-devtools MCP is unavailable or the user explicitly asks for headless smoke/debug.`,
+      `Browser interaction rule: if the user asks to click, press, fill, select, submit, open a web app path, or inspect page-by-page data, WebFetch is not enough and BrowserDebug is not user-visible. Use chrome-devtools MCP so the user can watch the normal Chrome client. Never claim "đã bấm/đã điền/đã mở/đã kiểm tra" from prose alone.`,
       `When a task touches coding, agents, UI, brand, or design, inspect the relevant required local resource in depth before deciding.`,
       `If the user asks you to modify, run, inspect, check, publish, commit, or otherwise act on the project, you MUST use tools. Do not claim completion without a tool result from this turn.`,
       ``,
       `## Debug Excellence`,
-      `For bugs, crashes, test failures, or "not working": identify the first hard failure, reproduce or inspect logs, trace the exact runtime path, patch the smallest root cause, and verify with the closest command. For frontend/runtime UI issues, use BrowserDebug when a URL or dev server is available.`,
+      `For bugs, crashes, test failures, or "not working": identify the first hard failure, reproduce or inspect logs, trace the exact runtime path, patch the smallest root cause, and verify with the closest command. For frontend/runtime UI issues with a URL/dev server, prefer chrome-devtools MCP in visible Chrome; use BrowserDebug only as a headless fallback.`,
       ``,
       `## Design Excellence`,
       `For UI/design work: inspect existing components/styles and any design resources first. Build a polished, responsive, domain-appropriate interface with complete states and clear interactions. Avoid generic placeholders, fake controls, one-note palettes, and unverified visual claims.`,
@@ -193,7 +195,7 @@ export class PromptBuilder {
       review: 'You are a Winter review subagent. Critique the request or implementation with specific issues, edge cases, and concrete improvements.',
       debug: 'You are a Winter debugging subagent. Reproduce or inspect the exact failing path, isolate the first hard blocker, patch the smallest root cause, and verify with the closest test/build/browser smoke.',
       research: 'You are a Winter research subagent. Gather the important facts, compare options, and summarize only what matters.',
-      browser: `You are a Winter browser subagent. Bạn CÓ QUYỀN sử dụng tool 'BrowserDebug' để tương tác với trình duyệt. Hãy dùng nó để mở URL, chụp ảnh màn hình (nếu cần), hoặc chạy JS để kiểm tra trang web.`,
+      browser: `You are a Winter browser subagent. Bạn CÓ QUYỀN sử dụng chrome-devtools MCP để thao tác Chrome visible cho user xem: mở URL, click, fill form, snapshot, screenshot, đọc console/network. Dùng BrowserDebug chỉ khi cần headless fallback.`,
     };
 
     const rolePrompt = rolePrompts[role] || 'You are a Winter coding subagent. Solve the task directly, use tools when needed, and return a concise result.';
@@ -208,14 +210,14 @@ export class PromptBuilder {
       '3. [DEBUG EXCELLENCE]: Reproduce or inspect the failing path first, isolate the first hard blocker, patch root cause, and verify with the closest test/build/browser smoke.',
       '4. [DESIGN EXCELLENCE]: Use rich aesthetics. Default to modern UI frameworks if applicable. Never output plain, ugly HTML/CSS. Ensure responsive, premium feel with micro-animations.',
       '5. [CODE QUALITY]: Write clean, modular, SOLID code. Check for syntax errors carefully. Do not generate incomplete code blocks.',
-      '6. [NO HALLUCINATION]: If you don\'t know, use tools (Grep/Read/Web/BrowserDebug) to find out. Do not guess file paths or APIs.',
+      '6. [NO HALLUCINATION]: If you don\'t know, use tools (Grep/Read/Web/chrome-devtools MCP/BrowserDebug) to find out. Do not guess file paths or APIs.',
       '7. [TOOL EXECUTION FIRST]: You DO have file tools. Use Write to create/overwrite files and Edit to patch files. Never say there is no write tool.',
       '8. [IMAGE INPUTS]: If an image is attached or pasted, analyze it directly and use it as evidence for UI/debug/design decisions.',
       '',
       rolePrompt,
       '',
       '## Tool Rules',
-      '- Canonical tools: Read, Write, Edit, Bash, Glob, Grep, TaskCreate, TaskUpdate, TaskList, BrowserDebug, WebFetch, WebSearch.',
+      '- Canonical tools: Read, Write, Edit, Bash, Glob, Grep, TaskCreate, TaskUpdate, TaskList, OpenBrowser, BrowserDebug, WebFetch, WebSearch, MCP.',
       '- If native tool calls are unavailable, output exactly one fallback tool call and no prose: <invoke name="Read"><parameter name="path">README.md</parameter></invoke> OR {"tool":"Read","arguments":{"path":"README.md"}} OR CALL_TOOL Read {"path":"README.md"}.',
       '- Treat skills, memories, bundled resources, local project rules, and the tool list as operational context. Use them proactively when relevant.',
       `- Runtime environment:\n${runtimeSummary}`,

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']);
     }
   }
 
@@ -1783,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;
@@ -1812,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;
@@ -1820,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;
@@ -1830,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.',
       '',
@@ -1842,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>',
@@ -1864,6 +1984,10 @@ ${colors.reset}
 
     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;
@@ -1902,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;
@@ -2244,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,
       {
@@ -2256,6 +2387,7 @@ ${colors.reset}
           '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'),
       },
@@ -2268,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, {
@@ -2278,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();
       
@@ -2295,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 });
 
@@ -2321,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;
@@ -2341,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);
     }
@@ -3378,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:
@@ -3410,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) {
@@ -3421,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;
@@ -3435,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

@@ -41,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/presets.js

@@ -0,0 +1,114 @@
+export const CHROME_DEVTOOLS_MCP_NAME = 'chrome-devtools';
+
+const CHROME_DEVTOOLS_PACKAGE = 'chrome-devtools-mcp@latest';
+const CHROME_DEVTOOLS_SOURCE = 'https://github.com/ChromeDevTools/chrome-devtools-mcp';
+
+const CHROME_DEVTOOLS_FLAGS_WITH_VALUES = new Set([
+  '--browser-url',
+  '--channel',
+  '--executablePath',
+  '--logFile',
+  '--viewport',
+  '--proxy-server',
+]);
+
+const CHROME_DEVTOOLS_BOOLEAN_FLAGS = new Set([
+  '--headless',
+  '--isolated',
+  '--acceptInsecureCerts',
+  '--help',
+]);
+
+export function normalizeMcpPresetName(name = '') {
+  return String(name || '').trim().toLowerCase();
+}
+
+export function isChromeDevtoolsPreset(name = '') {
+  return ['chrome-devtools', 'chromedevtools', 'chrome', 'devtools', 'cdp'].includes(normalizeMcpPresetName(name));
+}
+
+export function buildChromeDevtoolsArgs(options = []) {
+  const input = Array.isArray(options) ? [...options] : [];
+  const args = ['-y', CHROME_DEVTOOLS_PACKAGE];
+
+  for (let index = 0; index < input.length; index += 1) {
+    const flag = input[index];
+    if (!String(flag || '').startsWith('--')) continue;
+
+    if (CHROME_DEVTOOLS_BOOLEAN_FLAGS.has(flag)) {
+      args.push(flag);
+      continue;
+    }
+
+    if (CHROME_DEVTOOLS_FLAGS_WITH_VALUES.has(flag)) {
+      const value = input[index + 1];
+      if (value === undefined || String(value).startsWith('--')) {
+        throw new Error(`Missing value for ${flag}`);
+      }
+      args.push(flag, String(value));
+      index += 1;
+    }
+  }
+
+  return args;
+}
+
+export function createChromeDevtoolsMcpServer(options = [], platform = process.platform, env = process.env) {
+  const npxArgs = buildChromeDevtoolsArgs(options);
+  const common = {
+    name: CHROME_DEVTOOLS_MCP_NAME,
+    enabled: true,
+    requestTimeoutMs: 60000,
+    metadata: {
+      preset: CHROME_DEVTOOLS_MCP_NAME,
+      source: CHROME_DEVTOOLS_SOURCE,
+      purpose: 'Chrome DevTools MCP for live browser automation, debugging, screenshots, console, network, and performance traces.',
+    },
+  };
+
+  if (platform === 'win32') {
+    return {
+      ...common,
+      command: 'cmd',
+      args: ['/c', 'npx', ...npxArgs],
+      env: {
+        SystemRoot: env.SystemRoot || 'C:\\Windows',
+        PROGRAMFILES: env.PROGRAMFILES || 'C:\\Program Files',
+      },
+    };
+  }
+
+  return {
+    ...common,
+    command: 'npx',
+    args: npxArgs,
+  };
+}
+
+export function getMcpPreset(name, options = []) {
+  if (isChromeDevtoolsPreset(name)) {
+    return createChromeDevtoolsMcpServer(options);
+  }
+  throw new Error(`Unknown MCP preset: ${name}`);
+}
+
+export function ensureMcpConfigShape(config = {}) {
+  config.mcp = config.mcp || { servers: [] };
+  config.mcp.servers = Array.isArray(config.mcp.servers) ? config.mcp.servers : [];
+  config.permissions = config.permissions || { allowlist: {} };
+  config.permissions.allowlist = config.permissions.allowlist || {};
+  config.permissions.allowlist.tools = config.permissions.allowlist.tools || [];
+  config.permissions.allowlist.commands = config.permissions.allowlist.commands || [];
+  config.permissions.allowlist.mcpServers = config.permissions.allowlist.mcpServers || [];
+  return config;
+}
+
+export function upsertMcpServer(config, server) {
+  ensureMcpConfigShape(config);
+  config.mcp.servers = config.mcp.servers.filter(item => item.name !== server.name);
+  config.mcp.servers.push(server);
+  config.permissions.allowlist.mcpServers = [
+    ...new Set([...(config.permissions.allowlist.mcpServers || []), server.name]),
+  ];
+  return config;
+}

package/src/tools/executor.js

@@ -5,7 +5,7 @@
 
 import { promises as fs } from 'fs';
 import path from 'path';
-import { exec, execFile } from 'child_process';
+import { exec, execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { diffLines } from 'diff';
 import { withRetry } from './retry.js';
@@ -207,11 +207,11 @@ export class ToolExecutor {
       {
         type: 'function',
         name: 'MCP',
-        description: 'Call a configured MCP server tool by name. Use for external integrations and IDE-like tools. Discover available MCP tools via the MCP tool with server name and tool=list. Also, tools from MCP servers are exposed with mcp__<server>__<tool> naming for direct IDE integration (e.g. mcp__vscode__open_file).',
+        description: 'Call a configured MCP server tool by name. Use for external integrations and IDE-like tools. Discover available MCP tools via the MCP tool with server name and tool=list. For live Chrome debugging, use server chrome-devtools with tools such as new_page, navigate_page, take_snapshot, take_screenshot, evaluate_script, list_console_messages, list_network_requests, and performance trace tools. Also, tools from MCP servers are exposed with mcp__<server>__<tool> naming for direct IDE integration (e.g. mcp__vscode__open_file).',
         parameters: {
           type: 'object',
           properties: {
-            server: { type: 'string', description: 'Configured MCP server name (e.g. vscode)' },
+            server: { type: 'string', description: 'Configured MCP server name (e.g. vscode, chrome-devtools)' },
             tool: { type: 'string', description: 'MCP tool name, or set to "list" to discover all tools from a server' },
             arguments: { type: 'object', description: 'Tool arguments' },
           },
@@ -388,6 +388,18 @@ export class ToolExecutor {
           required: ['url']
         }
       },
+      {
+        type: 'function',
+        name: 'OpenBrowser',
+        description: 'Open Chrome or the default browser visibly for the user. Use this for requests like "mở chrome", "open Chrome", or "open this URL in browser". Do not use Bash/Start-Process for this.',
+        parameters: {
+          type: 'object',
+          properties: {
+            url: { type: 'string', description: 'URL to open. Defaults to about:blank.' },
+            browser: { type: 'string', description: 'chrome or default. Defaults to chrome.' },
+          }
+        }
+      },
       {
         type: 'function',
         name: 'WebFetch',
@@ -532,6 +544,8 @@ export class ToolExecutor {
         return await this.parallelExecute(input.tools ?? input.calls ?? [], { cwd });
       case 'BrowserDebug':
         return await this.browserDebug(input.url ?? input.uri, input.action);
+      case 'OpenBrowser':
+        return await this.openBrowser(input.url ?? input.uri ?? input.href, input.browser);
       case 'WebFetch':
         return await this.webFetch(input.url ?? input.uri ?? input.href, input.prompt ?? input.query ?? input.extract);
       case 'WebSearch':
@@ -572,7 +586,7 @@ export class ToolExecutor {
         return {
           success: false,
           error: `Unknown tool: ${toolName}`,
-          availableTools: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'TaskCreate', 'TaskUpdate', 'TaskList', 'MCP', 'Parallel', 'BrowserDebug', 'WebFetch', 'WebSearch', 'WebArchive', 'HtmlEffectiveness', 'NotebookRead', 'NotebookEdit', 'TodoWrite', 'TodoList', 'ScheduleWakeup', 'AskUserQuestion', 'Agent', 'InsertText', 'StrReplaceAll'],
+          availableTools: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'TaskCreate', 'TaskUpdate', 'TaskList', 'MCP', 'Parallel', 'OpenBrowser', 'BrowserDebug', 'WebFetch', 'WebSearch', 'WebArchive', 'HtmlEffectiveness', 'NotebookRead', 'NotebookEdit', 'TodoWrite', 'TodoList', 'ScheduleWakeup', 'AskUserQuestion', 'Agent', 'InsertText', 'StrReplaceAll'],
           recovery: 'Call one of the available tools. For file writes use Write with { "file_path": "...", "content": "..." }. For shell commands use Bash with { "command": "..." }.',
         };
     }
@@ -725,6 +739,12 @@ export class ToolExecutor {
       return { success: true, coerced: true, args: next };
     }
 
+    if (toolName === 'OpenBrowser') {
+      const url = pick('url', 'uri', 'href') || 'about:blank';
+      const browser = pick('browser', 'app') || 'chrome';
+      return { success: true, coerced: true, args: { ...args, url, browser } };
+    }
+
     if (toolName === 'WebSearch') {
       const query = pick('query', 'q', 'search', 'search_query', 'searchQuery');
       if (!query) {
@@ -752,6 +772,14 @@ export class ToolExecutor {
     const baseCommand = this.getBaseCommand(text);
     if (!baseCommand) return { success: true };
 
+    if (/^(?:get-command|start-process|start|open|xdg-open)$/i.test(baseCommand) && /\b(chrome|browser|google chrome)\b/i.test(text)) {
+      return {
+        success: false,
+        error: `Use OpenBrowser instead of shell command for browser launch: ${baseCommand}`,
+        recovery: 'Call OpenBrowser {"browser":"chrome","url":"about:blank"} for "mở chrome", or OpenBrowser {"browser":"chrome","url":"https://example.com"} for a specific URL.',
+      };
+    }
+
     const cfg = await this.getRuntimeConfig();
     const permissionCommands = cfg.permissions?.allowlist?.commands || [];
     const sandbox = cfg.sandbox || {};
@@ -974,6 +1002,11 @@ export class ToolExecutor {
       searchweb: 'WebSearch',
       internetsearch: 'WebSearch',
       googlesearch: 'WebSearch',
+      openbrowser: 'OpenBrowser',
+      open_browser: 'OpenBrowser',
+      browseropen: 'OpenBrowser',
+      openchrome: 'OpenBrowser',
+      launchchrome: 'OpenBrowser',
       browserdebug: 'BrowserDebug',
       browser: 'BrowserDebug',
       browserinspect: 'BrowserDebug',
@@ -2076,6 +2109,72 @@ export class ToolExecutor {
     }
   }
 
+  buildBrowserLaunchCommand(url = 'about:blank', browser = 'chrome', platform = process.platform) {
+    const targetUrl = String(url || 'about:blank');
+    const targetBrowser = String(browser || 'chrome').toLowerCase();
+
+    if (platform === 'win32') {
+      if (targetBrowser === 'default') {
+        return { command: 'cmd', args: ['/c', 'start', '', targetUrl] };
+      }
+      return { command: 'cmd', args: ['/c', 'start', '', 'chrome', targetUrl] };
+    }
+
+    if (platform === 'darwin') {
+      if (targetBrowser === 'default') {
+        return { command: 'open', args: [targetUrl] };
+      }
+      return { command: 'open', args: ['-a', 'Google Chrome', targetUrl] };
+    }
+
+    if (targetBrowser === 'default') {
+      return { command: 'xdg-open', args: [targetUrl] };
+    }
+    return { command: 'google-chrome', args: [targetUrl] };
+  }
+
+  async openBrowser(url = 'about:blank', browser = 'chrome') {
+    const targetUrl = String(url || 'about:blank');
+    const targetBrowser = String(browser || 'chrome').toLowerCase();
+    const launch = this.buildBrowserLaunchCommand(targetUrl, targetBrowser);
+
+    return await new Promise(resolve => {
+      let child;
+      try {
+        child = spawn(launch.command, launch.args, {
+          detached: true,
+          stdio: 'ignore',
+          windowsHide: false,
+        });
+      } catch (error) {
+        resolve({
+          success: false,
+          error: error.message,
+          recovery: 'Install Chrome or retry with OpenBrowser {"browser":"default","url":"about:blank"}.',
+        });
+        return;
+      }
+
+      child.once('error', error => {
+        resolve({
+          success: false,
+          error: error.message,
+          recovery: 'Install Chrome or retry with OpenBrowser {"browser":"default","url":"about:blank"}.',
+        });
+      });
+      child.once('spawn', () => {
+        child.unref();
+        resolve({
+          success: true,
+          browser: targetBrowser,
+          url: targetUrl,
+          command: launch.command,
+          args: launch.args,
+        });
+      });
+    });
+  }
+
   async htmlEffectivenessCompile(input, cwd) {
     const inputPath = this.resolveInputPath(input.input_path ?? input.inputPath ?? input.input, cwd);
     const outputPath = this.resolveInputPath(input.output_path ?? input.outputPath ?? input.output, cwd);