chrome-devtools-mcp 1.2.0 → 1.4.0

package/skills/chrome-devtools/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: chrome-devtools
+description: Uses Chrome DevTools via MCP for efficient debugging, troubleshooting and browser automation. Use when debugging web pages, automating browser interactions, analyzing performance, or inspecting network requests. This skill does not apply to `--slim` mode (MCP configuration).
+---
+
+## Core Concepts
+
+**Browser lifecycle**: Browser starts automatically on first tool call using a persistent Chrome profile. Configure via CLI args in the MCP server configuration: `npx chrome-devtools-mcp@latest --help`.
+Addional tooling can be enabled by providing the following flags:
+
+- For extension tooling, use the `--categoryExtensions` flag.
+- For memory tooling, use the `--memoryDebugging` flag.
+
+**Page selection**: Tools operate on the currently selected page. Use `list_pages` to see available pages, then `select_page` to switch context.
+**Element interaction**: Use `take_snapshot` to get page structure with element `uid`s. Each element has a unique `uid` for interaction. If an element isn't found, take a fresh snapshot - the element may have been removed or the page changed.
+
+## Workflow Patterns
+
+### Before interacting with a page
+
+1. Navigate: `navigate_page` or `new_page`
+2. Wait: `wait_for` to ensure content is loaded if you know what you look for.
+3. Snapshot: `take_snapshot` to understand page structure
+4. Interact: Use element `uid`s from snapshot for `click`, `fill`, etc.
+
+### Efficient data retrieval
+
+- Use `filePath` parameter for large outputs (screenshots, snapshots, traces)
+- Use pagination (`pageIdx`, `pageSize`) and filtering (`types`) to minimize data
+- Set `includeSnapshot: false` on input actions unless you need updated page state
+
+### Tool selection
+
+- **Automation/interaction**: `take_snapshot` (text-based, faster, better for automation)
+- **Visual inspection**: `take_screenshot` (when user needs to see visual state)
+- **Additional details**: `evaluate_script` for data not in accessibility tree
+
+### Parallel execution
+
+You can send multiple tool calls in parallel, but maintain correct order: navigate → wait → snapshot → interact.
+
+### Testing an extension
+
+> **Before proceeding**: Extension tools (`install_extension`, `list_extensions`, etc.) are only available when the MCP server is started with the `--categoryExtensions` flag. If these tools are not in your tool list, stop and ask the user to update their MCP server configuration:
+>
+> ```json
+> {
+>   "mcpServers": {
+>     "chrome-devtools": {
+>       "command": "npx",
+>       "args": ["chrome-devtools-mcp@latest", "--categoryExtensions"]
+>     }
+>   }
+> }
+> ```
+>
+> After updating, the user must restart the MCP server (or their AI client) for the change to take effect.
+
+1. **Install**: Use `install_extension` with the path to the unpacked extension.
+2. **Identify**: Get the extension ID from the response or by calling `list_extensions`.
+3. **Trigger Action**: Use `trigger_extension_action` to open the popup or side panel if applicable.
+4. **Verify Service Worker**: Use `evaluate_script` with `serviceWorkerId` to check extension state or trigger background actions.
+5. **Verify Page Behavior**: Navigate to a page where the extension operates and use `take_snapshot` to check if content scripts injected elements or modified the page correctly.
+
+## Troubleshooting
+
+If `chrome-devtools-mcp` is insufficient, guide users to use Chrome DevTools UI:
+
+- https://developer.chrome.com/docs/devtools
+- https://developer.chrome.com/docs/devtools/ai-assistance
+
+If there are errors launching `chrome-devtools-mcp` or Chrome, refer to https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/troubleshooting.md.

package/skills/chrome-devtools-cli/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: chrome-devtools-cli
+description: Use this skill to write shell scripts or run shell commands to automate tasks in the browser or otherwise use Chrome DevTools via CLI.
+---
+
+The `chrome-devtools-mcp` CLI lets you interact with the browser from your terminal.
+
+## Setup
+
+_Note: If this is your very first time using the CLI, see [references/installation.md](references/installation.md) for setup. Installation is a one-time prerequisite and is **not** part of the regular AI workflow._
+
+## AI Workflow
+
+1. **Execute**: Run tools directly (e.g., `chrome-devtools list_pages`). The background server starts implicitly; **do not** run `start`/`status`/`stop` before each use.
+2. **Inspect**: Use `take_snapshot` to get an element `<uid>`.
+3. **Act**: Use `click`, `fill`, etc. State persists across commands.
+
+Snapshot example:
+
+```
+uid=1_0 RootWebArea "Example Domain" url="https://example.com/"
+  uid=1_1 heading "Example Domain" level="1"
+```
+
+## Command Usage
+
+```sh
+chrome-devtools <tool> [arguments] [flags]
+```
+
+Use `--help` on any command. Output defaults to Markdown, use `--output-format=json` for JSON.
+
+## Input Automation (<uid> from snapshot)
+
+```bash
+chrome-devtools take_snapshot --help # Help message for commands, works for any command.
+chrome-devtools take_snapshot # Take a text snapshot of the page to get UIDs for elements
+chrome-devtools click "id" # Clicks on the provided element
+chrome-devtools click "id" --dblClick true --includeSnapshot true # Double clicks and returns a snapshot
+chrome-devtools drag "src" "dst" # Drag an element onto another element
+chrome-devtools drag "src" "dst" --includeSnapshot true # Drag an element and return a snapshot
+chrome-devtools fill "id" "text" # Type text into an input or select an option
+chrome-devtools fill "id" "text" --includeSnapshot true # Fill an element and return a snapshot
+chrome-devtools handle_dialog accept # Handle a browser dialog
+chrome-devtools handle_dialog dismiss --promptText "hi" # Dismiss a dialog with prompt text
+chrome-devtools hover "id" # Hover over the provided element
+chrome-devtools hover "id" --includeSnapshot true # Hover over an element and return a snapshot
+chrome-devtools press_key "Enter" # Press a key or key combination
+chrome-devtools press_key "Control+A" --includeSnapshot true # Press a key and return a snapshot
+chrome-devtools type_text "hello" # Type text using keyboard into a focused input
+chrome-devtools type_text "hello" --submitKey "Enter" # Type text and press a submit key
+chrome-devtools upload_file "id" "file.txt" # Upload a file through a provided element
+chrome-devtools upload_file "id" "file.txt" --includeSnapshot true # Upload a file and return a snapshot
+```
+
+## Navigation
+
+```bash
+chrome-devtools close_page 1 # Closes the page by its index
+chrome-devtools list_pages # Get a list of pages open in the browser
+chrome-devtools navigate_page --url "https://example.com" # Navigates the currently selected page to a URL
+chrome-devtools navigate_page --type "reload" --ignoreCache true # Reload page ignoring cache
+chrome-devtools navigate_page --url "https://example.com" --timeout 5000 # Navigate with a timeout
+chrome-devtools navigate_page --handleBeforeUnload "accept" # Handle before unload dialog
+chrome-devtools navigate_page --type "back" --initScript "foo()" # Navigate back and run an init script
+chrome-devtools new_page "https://example.com" # Creates a new page
+chrome-devtools new_page "https://example.com" --background true --timeout 5000 # Create new page in background
+chrome-devtools new_page "https://example.com" --isolatedContext "ctx" # Create new page with isolated context
+chrome-devtools select_page 1 # Select a page as a context for future tool calls
+chrome-devtools select_page 1 --bringToFront true # Select a page and bring it to front
+```
+
+## Emulation
+
+```bash
+chrome-devtools emulate --networkConditions "Offline" # Emulate network conditions
+chrome-devtools emulate --cpuThrottlingRate 4 --geolocation "0x0" # Emulate CPU throttling and geolocation
+chrome-devtools emulate --colorScheme "dark" --viewport "1920x1080" # Emulate color scheme and viewport
+chrome-devtools emulate --userAgent "Mozilla/5.0..." # Emulate user agent
+chrome-devtools resize_page 1920 1080 # Resizes the selected page's window
+```
+
+## Performance
+
+```bash
+chrome-devtools performance_analyze_insight "1" "LCPBreakdown" # Get more details on a specific Performance Insight
+chrome-devtools performance_start_trace true false # Starts a performance trace recording
+chrome-devtools performance_start_trace true true --filePath t.gz # Start trace and save to a file
+chrome-devtools performance_stop_trace # Stops the active performance trace
+chrome-devtools performance_stop_trace --filePath "t.json" # Stop trace and save to a file
+chrome-devtools take_memory_snapshot "./snap.heapsnapshot" # Capture a memory heapsnapshot
+```
+
+## Network
+
+```bash
+chrome-devtools get_network_request # Get the currently selected network request
+chrome-devtools get_network_request --reqid 1 --requestFilePath req.md # Get request by id and save to file
+chrome-devtools get_network_request --responseFilePath res.md # Save response body to file
+chrome-devtools list_network_requests # List all network requests
+chrome-devtools list_network_requests --pageSize 50 --pageIdx 0 # List network requests with pagination
+chrome-devtools list_network_requests --resourceTypes Fetch # Filter requests by resource type
+chrome-devtools list_network_requests --includePreservedRequests true # Include preserved requests
+```
+
+## Debugging & Inspection
+
+```bash
+chrome-devtools evaluate_script "() => document.title" # Evaluate a JavaScript function on the page
+chrome-devtools evaluate_script "(a) => a.innerText" --args 1_4 # Evaluate JS with UID arguments
+chrome-devtools get_console_message 1 # Gets a console message by its ID
+chrome-devtools lighthouse_audit --mode "navigation" # Run Lighthouse audit for navigation
+chrome-devtools lighthouse_audit --mode "snapshot" --device "mobile" # Run Lighthouse audit for a snapshot on mobile
+chrome-devtools lighthouse_audit --outputDirPath ./out # Run Lighthouse audit and save reports
+chrome-devtools list_console_messages # List all console messages
+chrome-devtools list_console_messages --pageSize 20 --pageIdx 1 # List console messages with pagination
+chrome-devtools list_console_messages --types error --types info # Filter console messages by type
+chrome-devtools list_console_messages --includePreservedMessages true # Include preserved messages
+chrome-devtools take_screenshot # Take a screenshot of the page viewport
+chrome-devtools take_screenshot --fullPage true --format "jpeg" --quality 80 # Take a full page screenshot as JPEG with quality
+chrome-devtools take_screenshot --uid "id" --filePath "s.png" # Take a screenshot of an element
+chrome-devtools take_snapshot # Take a text snapshot of the page from the a11y tree
+chrome-devtools take_snapshot --verbose true --filePath "s.txt" # Take a verbose snapshot and save to file
+```
+
+## Extensions
+
+```bash
+chrome-devtools list_extensions # Lists all the Chrome extensions installed in the browser
+chrome-devtools install_extension "/path/to/extension" # Installs a Chrome extension from the given path
+chrome-devtools uninstall_extension "extension_id" # Uninstalls a Chrome extension by its ID
+chrome-devtools reload_extension "extension_id" # Reloads an unpacked Chrome extension by its ID
+chrome-devtools trigger_extension_action "extension_id" # Triggers the default action of an extension by its ID
+```
+
+## Experimental Features
+
+Experimental tools are disabled by default. Enable them with the corresponding flag during `start`.
+
+```bash
+chrome-devtools click_at 100 200 # Clicks at the provided coordinates (requires --experimentalVision=true)
+chrome-devtools screencast_start # Starts a screencast recording (requires --experimentalScreencast=true and ffmpeg)
+chrome-devtools screencast_stop # Stops the active screencast
+chrome-devtools list_webmcp_tools # List all WebMCP tools (requires --categoryExperimentalWebmcp=true)
+```
+
+## Service Management
+
+```bash
+chrome-devtools start   # Start or restart chrome-devtools-mcp
+chrome-devtools status  # Checks if chrome-devtools-mcp is running
+chrome-devtools stop    # Stop chrome-devtools-mcp if any
+```

package/skills/chrome-devtools-cli/references/installation.md

@@ -0,0 +1,14 @@
+# Installation
+
+Install the package globally to make the `chrome-devtools` command available. You only need to do this the first time you use it.
+
+```sh
+npm i chrome-devtools-mcp@latest -g
+chrome-devtools status # check if install worked.
+```
+
+## Troubleshooting
+
+- **Command not found:** If `chrome-devtools` is not recognized, ensure your global npm `bin` directory is in your system's `PATH`. Restart your terminal or source your shell configuration file (e.g., `.bashrc`, `.zshrc`).
+- **Permission errors:** If you encounter `EACCES` or permission errors during installation, avoid using `sudo`. Instead, use a node version manager like `nvm`, or configure npm to use a different global directory.
+- **Old version running:** Run `chrome-devtools stop && npm uninstall -g chrome-devtools-mcp` before reinstalling, or ensure the latest version is being picked up by your path.

package/skills/debug-optimize-lcp/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: debug-optimize-lcp
+description: Guides debugging and optimizing Largest Contentful Paint (LCP) using Chrome DevTools MCP tools. Use this skill whenever the user asks about LCP performance, slow page loads, Core Web Vitals optimization, or wants to understand why their page's main content takes too long to appear. Also use when the user mentions "largest contentful paint", "page load speed", "CWV", or wants to improve how fast their hero image or main content renders.
+---
+
+## What is LCP and why it matters
+
+Largest Contentful Paint (LCP) measures how quickly a page's main content becomes visible. It's the time from navigation start until the largest image or text block renders in the viewport.
+
+- **Good**: 2.5 seconds or less
+- **Needs improvement**: 2.5–4.0 seconds
+- **Poor**: greater than 4.0 seconds
+
+LCP is a Core Web Vital that directly affects user experience and search ranking. On 73% of mobile pages, the LCP element is an image.
+
+## LCP Subparts Breakdown
+
+Every page's LCP breaks down into four sequential subparts with no gaps or overlaps. Understanding which subpart is the bottleneck is the key to effective optimization.
+
+| Subpart                       | Ideal % of LCP | What it measures                               |
+| ----------------------------- | -------------- | ---------------------------------------------- |
+| **Time to First Byte (TTFB)** | ~40%           | Navigation start → first byte of HTML received |
+| **Resource load delay**       | <10%           | TTFB → browser starts loading the LCP resource |
+| **Resource load duration**    | ~40%           | Time to download the LCP resource              |
+| **Element render delay**      | <10%           | LCP resource downloaded → LCP element rendered |
+
+The "delay" subparts should be as close to zero as possible. If either delay subpart is large relative to the total LCP, that's the first place to optimize.
+
+**Common Pitfall**: Optimizing one subpart (like compressing an image to reduce load duration) without checking others. If render delay is the real bottleneck, a smaller image won't help — the saved time just shifts to render delay.
+
+## Debugging Workflow
+
+Follow these steps in order. Each step builds on the previous one.
+
+### Step 1: Record a Performance Trace
+
+Navigate to the page, then record a trace with reload to capture the full page load including LCP:
+
+1. `navigate_page` to the target URL.
+2. `performance_start_trace` with `reload: true` and `autoStop: true`.
+
+The trace results will include LCP timing and available insight sets. Note the insight set IDs from the output — you'll need them in the next step.
+
+### Step 2: Analyze LCP Insights
+
+Use `performance_analyze_insight` to drill into LCP-specific insights. Look for these insight names in the trace results:
+
+- **LCPBreakdown** — Shows the four LCP subparts with timing for each.
+- **DocumentLatency** — Server response time issues affecting TTFB.
+- **RenderBlocking** — Resources blocking the LCP element from rendering.
+- **LCPDiscovery** — Whether the LCP resource was discoverable early.
+
+Call `performance_analyze_insight` with the insight set ID and the insight name from the trace results.
+
+### Step 3: Identify the LCP Element
+
+Use `evaluate_script` with the **"Identify LCP Element" snippet** found in [references/lcp-snippets.md](references/lcp-snippets.md) to reveal the LCP element's tag, resource URL, and raw timing data.
+
+The `url` field tells you what resource to look for in the network waterfall. If `url` is empty, the LCP element is text-based (no resource to load).
+
+### Step 4: Check the Network Waterfall
+
+Use `list_network_requests` to see when the LCP resource loaded relative to other resources:
+
+- Call `list_network_requests` filtered by `resourceTypes: ["Image", "Font"]` (adjust based on Step 3).
+- Then use `get_network_request` with the LCP resource's request ID for full details.
+
+**Key Checks:**
+
+- **Start Time**: Compare against the HTML document and the first resource. If the LCP resource starts much later than the first resource, there's resource load delay to eliminate.
+- **Duration**: A large resource load duration suggests the file is too big or the server is slow.
+
+### Step 5: Inspect HTML for Common Issues
+
+Use `evaluate_script` with the **"Audit Common Issues" snippet** found in [references/lcp-snippets.md](references/lcp-snippets.md) to check for lazy-loaded images in the viewport, missing fetchpriority, and render-blocking scripts.
+
+## Optimization Strategies
+
+After identifying the bottleneck subpart, apply these prioritized fixes.
+
+### 1. Eliminate Resource Load Delay (target: <10%)
+
+The most common bottleneck. The LCP resource should start loading immediately.
+
+- **Root Cause**: LCP image loaded via JS/CSS, `data-src` usage, or `loading="lazy"`.
+- **Fix**: Use standard `<img>` with `src`. **Never** lazy-load the LCP image.
+- **Fix**: Add `<link rel="preload" fetchpriority="high">` if the image isn't discoverable in HTML.
+- **Fix**: Add `fetchpriority="high"` to the LCP `<img>` tag.
+
+### 2. Eliminate Element Render Delay (target: <10%)
+
+The element should render immediately after loading.
+
+- **Root Cause**: Large stylesheets, synchronous scripts in `<head>`, or main thread blocking.
+- **Fix**: Inline critical CSS, defer non-critical CSS/JS.
+- **Fix**: Break up long tasks blocking the main thread.
+- **Fix**: Use Server-Side Rendering (SSR) so the element exists in initial HTML.
+
+### 3. Reduce Resource Load Duration (target: ~40%)
+
+Make the resource smaller or faster to deliver.
+
+- **Fix**: Use modern formats (WebP, AVIF) and responsive images (`srcset`).
+- **Fix**: Serve from a CDN.
+- **Fix**: Set `Cache-Control` headers.
+- **Fix**: Use `font-display: swap` if LCP is text blocked by a web font.
+
+### 4. Reduce TTFB (target: ~40%)
+
+The HTML document itself takes too long to arrive.
+
+- **Fix**: Minimize redirects and optimize server response time.
+- **Fix**: Cache HTML at the edge (CDN).
+- **Fix**: Ensure pages are eligible for back/forward cache (bfcache).
+
+## Verifying Fixes & Emulation
+
+- **Verification**: Re-run the trace (`performance_start_trace` with `reload: true`) and compare the new subpart breakdown. The bottleneck should shrink.
+- **Emulation**: Lab measurements differ from real-world experience. Use `emulate` to test under constraints:
+  - `emulate` with `networkConditions: "Fast 3G"` and `cpuThrottlingRate: 4`.
+  - This surfaces issues visible only on slower connections/devices.

package/skills/debug-optimize-lcp/references/elements-and-size.md

@@ -0,0 +1,27 @@
+# Elements and Size for LCP
+
+## What Elements are Considered?
+
+The types of elements considered for Largest Contentful Paint (LCP) are:
+
+- **`<img>` elements**: The first frame presentation time is used for animated content like GIFs.
+- **`<image>` elements** inside an `<svg>` element.
+- **`<video>` elements**: The poster image load time or first frame presentation time, whichever is earlier.
+- **Background images**: Elements with a background image loaded using `url()`.
+- **Block-level elements**: Containing text nodes or other inline-level text element children.
+
+## Heuristics to Exclude Non-Contentful Elements
+
+Chromium-based browsers use heuristics to exclude:
+
+- Elements with **opacity of 0**.
+- Elements that **cover the full viewport** (likely background).
+- **Placeholder images** or low-entropy images.
+
+## How is an Element's Size Determined?
+
+- **Visible Area**: Typically the size visible within the viewport. Extending outside, clipped, or overflow portions don't count.
+- **Image Elements**: Either the visible size or the intrinsic size, whichever is smaller.
+- **Text Elements**: The smallest rectangle containing all text nodes.
+- **Exclusions**: Margin, padding, and borders are not considered toward the size.
+- **Containment**: Every text node belongs to its closest block-level ancestor element.

package/skills/debug-optimize-lcp/references/lcp-breakdown.md

@@ -0,0 +1,23 @@
+# Largest Contentful Paint (LCP) Breakdown
+
+LCP measures the time from when the user initiates loading the page until the largest image or text block is rendered within the viewport. To provide a good user experience, sites should strive to have an LCP of 2.5 seconds or less for at least 75% of page visits.
+
+## The Four Subparts of LCP
+
+Every page's LCP consists of these four subcategories. There's no gap or overlap between them, and they add up to the full LCP time.
+
+| LCP subpart                   | % of LCP (Optimal) | Description                                                                                                                                                              |
+| ----------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Time to First Byte (TTFB)** | ~40%               | The time from when the user initiates loading the page until the browser receives the first byte of the HTML document response.                                          |
+| **Resource load delay**       | <10%               | The time between TTFB and when the browser starts loading the LCP resource. If the LCP element doesn't require a resource load (e.g., system font text), this time is 0. |
+| **Resource load duration**    | ~40%               | The duration of time it takes to load the LCP resource itself. If the LCP element doesn't require a resource load, this time is 0.                                       |
+| **Element render delay**      | <10%               | The time between when the LCP resource finishes loading and the LCP element rendering fully.                                                                             |
+
+## Why the Breakdown Matters
+
+Optimizing for LCP requires identifying which of these subparts is the bottleneck:
+
+- **Large delta between TTFB and FCP**: Indicates the browser needs to download a lot of render-blocking assets or complete a lot of work (e.g., client-side rendering).
+- **Large delta between FCP and LCP**: Indicates the LCP resource is not immediately available for the browser to prioritize or the browser is completing other work before it can display the LCP content.
+- **Large resource load delay**: Indicates the resource is not discoverable early or is deprioritized.
+- **Large element render delay**: Indicates rendering is blocked by stylesheets, scripts, or long tasks.

package/skills/debug-optimize-lcp/references/lcp-snippets.md

@@ -0,0 +1,79 @@
+# LCP Debugging Snippets
+
+Use these JavaScript snippets with the `evaluate_script` tool to extract deep insights from the page.
+
+## 1. Identify LCP Element
+
+Use this snippet to identify the LCP element and get raw timing data from the Performance API.
+
+```javascript
+async () => {
+  return await new Promise(resolve => {
+    new PerformanceObserver(list => {
+      const entries = list.getEntries();
+      const last = entries[entries.length - 1];
+      resolve({
+        element: last.element?.tagName,
+        id: last.element?.id,
+        className: last.element?.className,
+        url: last.url,
+        startTime: last.startTime,
+        renderTime: last.renderTime,
+        loadTime: last.loadTime,
+        size: last.size,
+      });
+    }).observe({type: 'largest-contentful-paint', buffered: true});
+  });
+};
+```
+
+## 2. Audit Common Issues
+
+Use this snippet to check for common DOM-based LCP issues (lazy loading, priority).
+
+```javascript
+() => {
+  const issues = [];
+
+  // Check for lazy-loaded images in viewport
+  document.querySelectorAll('img[loading="lazy"]').forEach(img => {
+    const rect = img.getBoundingClientRect();
+    if (rect.top < window.innerHeight) {
+      issues.push({
+        issue: 'lazy-loaded image in viewport',
+        element: img.outerHTML.substring(0, 200),
+        fix: 'Remove loading="lazy" from this image — it is in the initial viewport and may be the LCP element',
+      });
+    }
+  });
+
+  // Check for LCP-candidate images missing fetchpriority
+  document.querySelectorAll('img:not([fetchpriority])').forEach(img => {
+    const rect = img.getBoundingClientRect();
+    if (rect.top < window.innerHeight && rect.width * rect.height > 50000) {
+      issues.push({
+        issue: 'large viewport image without fetchpriority',
+        element: img.outerHTML.substring(0, 200),
+        fix: 'Add fetchpriority="high" to this image — it is large and visible in the initial viewport',
+      });
+    }
+  });
+
+  // Check for render-blocking scripts in head
+  document
+    .querySelectorAll(
+      'head script:not([async]):not([defer]):not([type="module"])',
+    )
+    .forEach(script => {
+      if (script.src) {
+        issues.push({
+          issue: 'render-blocking script in head',
+          element: script.outerHTML.substring(0, 200),
+          fix: 'Add async or defer attribute, or move to end of body',
+        });
+      }
+    });
+
+  return {issueCount: issues.length, issues};
+};
+```

package/skills/debug-optimize-lcp/references/optimization-strategies.md

@@ -0,0 +1,38 @@
+# LCP Optimization Strategies
+
+## 1. Eliminate Resource Load Delay
+
+**Goal**: Ensure the LCP resource starts loading as early as possible.
+
+- **Early Discovery**: Ensure the LCP resource is discoverable in the initial HTML document response (not dynamically added by JS or hidden in `data-src`).
+- **Preload**: Use `<link rel="preload">` with `fetchpriority="high"` for critical images or fonts.
+- **Avoid Lazy Loading**: Never set `loading="lazy"` on the LCP image.
+- **Fetch Priority**: Use `fetchpriority="high"` on the `<img>` tag.
+- **Same Origin**: Host critical resources on the same origin or use `<link rel="preconnect">`.
+
+## 2. Eliminate Element Render Delay
+
+**Goal**: Ensure the LCP element can render immediately after its resource has finished loading.
+
+- **Minimize Render-Blocking CSS**: Inline critical CSS and defer non-critical CSS. Ensure the stylesheet is smaller than the LCP resource.
+- **Minimize Render-Blocking JS**: Avoid synchronous scripts in the `<head>`. Inline very small scripts.
+- **Server-Side Rendering (SSR)**: Deliver the full HTML markup from the server so image resources are discoverable immediately.
+- **Break Up Long Tasks**: Prevent large JavaScript tasks from blocking the main thread during rendering.
+
+## 3. Reduce Resource Load Duration
+
+**Goal**: Reduce the time spent transferring the bytes of the resource.
+
+- **Optimize Resource Size**: Serve optimal image sizes, use modern formats (AVIF, WebP), and compress images/fonts.
+- **Geographic Proximity (CDN)**: Use a Content Delivery Network to get servers closer to users.
+- **Reduce Contention**: Use `fetchpriority="high"` to prevent lower-priority resources from competing for bandwidth.
+- **Caching**: Use efficient `Cache-Control` policies.
+
+## 4. Reduce Time to First Byte (TTFB)
+
+**Goal**: Deliver the initial HTML as quickly as possible.
+
+- **Minimize Redirects**: Avoid multiple redirects from advertisements or shortened links.
+- **CDN Caching**: Cache static HTML documents at the edge.
+- **Edge Computing**: Move dynamic logic to the edge to avoid trips to the origin server.
+- **Back/Forward Cache**: Ensure pages are eligible for bfcache.

package/skills/memory-leak-debugging/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: memory-leak-debugging
+description: Diagnoses and resolves memory leaks in JavaScript/Node.js applications. Use when a user reports high memory usage, OOM errors, or wants to analyze heapsnapshots or run memory leak detection tools like memlab.
+---
+
+# Memory Leak Debugging
+
+This skill provides expert guidance and workflows for finding, diagnosing, and fixing memory leaks in JavaScript and Node.js applications.
+
+## Core Principles
+
+- **Prefer `memlab`:** Do NOT attempt to read raw `.heapsnapshot` files directly, as they are extremely large and will consume too many tokens. Always recommend and use `memlab` to process snapshots and identify leak traces.
+- **Isolate the Leak:** Determine if the leak is in the browser (client-side) or Node.js (server-side).
+- **Common Culprits:** Look for detached DOM nodes, unhandled closures, global variables, event listeners not being removed, and caches growing unbounded. _Note: Detached DOM nodes are sometimes intentional caches; always ask the user before nulling them._
+
+## Workflows
+
+### 1. Capturing Snapshots
+
+When investigating a frontend web application memory leak, utilize the `chrome-devtools-mcp` tools to interact with the application and take snapshots.
+
+- Use tools like `click`, `navigate_page`, `fill`, etc., to manipulate the page into the desired state.
+- Revert the page back to the original state after interactions to see if memory is released.
+- Repeat the same user interactions 10 times to amplify the leak.
+- Use `take_heapsnapshot` to save `.heapsnapshot` files to disk at baseline, target (after actions), and final (after reverting actions) states.
+
+### 2. Using Memlab to Find Leaks (Recommended)
+
+Once you have generated `.heapsnapshot` files using `take_heapsnapshot`, use `memlab` to automatically find memory leaks.
+
+- Read [references/memlab.md](references/memlab.md) for how to use `memlab` to analyze the generated heapsnapshots.
+- Do **not** read raw `.heapsnapshot` files using `read_file` or `cat`.
+
+### 3. Identifying Common Leaks
+
+When you have found a leak trace (e.g., via `memlab` output), you must identify the root cause in the code.
+
+- Read [references/common-leaks.md](references/common-leaks.md) for examples of common memory leaks and how to fix them.
+
+### 4. Fallback: Comparing Snapshots Manually
+
+If `memlab` is not available, you MUST use the fallback script in the references directory to compare two `.heapsnapshot` files and identify the top growing objects and common leak types.
+
+Run the script using Node.js:
+
+```bash
+node skills/memory-leak-debugging/references/compare_snapshots.js <baseline.heapsnapshot> <target.heapsnapshot>
+```
+
+The script will analyze and output the top growing objects by size and highlight the 3 most common types of memory leaks (e.g., Detached DOM nodes, closures, Contexts) if they are present.

package/skills/memory-leak-debugging/references/common-leaks.md

@@ -0,0 +1,33 @@
+# Common Memory Leaks
+
+When analyzing a retainer trace from `memlab`, look for these common patterns in the codebase:
+
+## 1. Uncleared Event Listeners
+
+Event listeners attached to global objects (like `window` or `document`) or long-living objects prevent garbage collection of the objects referenced in their callbacks.
+
+**Fix:** Always call `removeEventListener` when a component unmounts or the listener is no longer needed.
+
+## 2. Detached DOM Nodes
+
+A DOM node is removed from the document tree but is still referenced by a JavaScript variable. While detachedness is a good signal for a memory leak, it's not always a bug. For example, websites sometimes intentionally cache detached navigation trees.
+
+**Fix:** Signal the detached nodes to the user first. **Ask the user first** before nulling the references or changing the code, as the detached nodes might be part of an intentional cache. If confirmed as a leak, ensure variables holding DOM references are set to `null` when the node is removed, or limit their scope.
+
+## 3. Unintentional Global Variables
+
+Variables declared without `var`, `let`, or `const` (in non-strict mode) or explicitly attached to `window` remain in memory forever.
+
+**Fix:** Use strict mode, properly declare variables, and avoid global state.
+
+## 4. Closures
+
+Closures can unintentionally keep references to large objects in their outer scope.
+
+**Fix:** Nullify large objects when they are no longer needed, or refactor the closure to not capture unnecessary variables.
+
+## 5. Unbounded Caches or Arrays
+
+Data structures used for caching (like objects, Arrays, or Maps) that grow without limits.
+
+**Fix:** Implement caching limits, use LRU caches, or use `WeakMap`/`WeakSet` for data associated with object lifecycles.