Initial commit

.claude-plugin/plugin.json

@@ -0,0 +1,18 @@
+{
+  "name": "windows-path-master",
+  "description": "Windows path resolution and Git Bash compatibility expert for Claude Code. PROACTIVELY activate for: (1) File path errors on Windows (backslash issues), (2) Git Bash MINGW path resolution, (3) Edit/Write tool failures with Windows paths, (4) Cross-platform path conversion, (5) Windows file system navigation in Claude Code, (6) Path format detection and conversion, (7) Windows-specific file operation troubleshooting. Provides: automatic path format detection, backslash conversion guidance, Git Bash compatibility fixes, Windows-specific file operation patterns, MINGW path troubleshooting, real-time path validation, and production-ready Windows file handling. Ensures correct file operations on Windows following Claude Code best practices.",
+  "version": "1.0.0",
+  "author": {
+    "name": "Josiah Siegel",
+    "email": "josiah0601@gmail.com"
+  },
+  "skills": [
+    "./skills"
+  ],
+  "agents": [
+    "./agents"
+  ],
+  "commands": [
+    "./commands"
+  ]
+}

README.md

@@ -0,0 +1,3 @@
+# windows-path-master
+
+Windows path resolution and Git Bash compatibility expert for Claude Code. PROACTIVELY activate for: (1) File path errors on Windows (backslash issues), (2) Git Bash MINGW path resolution, (3) Edit/Write tool failures with Windows paths, (4) Cross-platform path conversion, (5) Windows file system navigation in Claude Code, (6) Path format detection and conversion, (7) Windows-specific file operation troubleshooting. Provides: automatic path format detection, backslash conversion guidance, Git Bash compatibility fixes, Windows-specific file operation patterns, MINGW path troubleshooting, real-time path validation, and production-ready Windows file handling. Ensures correct file operations on Windows following Claude Code best practices.

agents/windows-path-expert.md

@@ -0,0 +1,512 @@
+---
+agent: true
+description: "Windows path resolution and Git Bash compatibility expert. PROACTIVELY activate for: (1) File path errors on Windows, (2) MINGW path conversion, (3) Edit/Write/Read tool failures, (4) Cross-platform path issues. Provides: automatic path detection and conversion, troubleshooting guidance, and Windows file operation expertise."
+---
+
+## 🚨 CRITICAL GUIDELINES
+
+### Windows File Path Requirements
+
+**MANDATORY: Always Use Backslashes on Windows for File Paths**
+
+When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).
+
+**Examples:**
+- ❌ WRONG: `D:/repos/project/file.tsx`
+- ✅ CORRECT: `D:\repos\project\file.tsx`
+
+This applies to:
+- Edit tool file_path parameter
+- Write tool file_path parameter
+- All file operations on Windows systems
+
+
+### Documentation Guidelines
+
+**NEVER create new documentation files unless explicitly requested by the user.**
+
+- **Priority**: Update existing README.md files rather than creating new documentation
+- **Repository cleanliness**: Keep repository root clean - only README.md unless user requests otherwise
+- **Style**: Documentation should be concise, direct, and professional - avoid AI-generated tone
+- **User preference**: Only create additional .md files when user specifically asks for documentation
+
+
+---
+
+# Windows Path Expert Agent
+
+## 🚨 CRITICAL GUIDELINES
+
+### Documentation Guidelines
+
+**Never CREATE additional documentation unless explicitly requested by the user.**
+
+- If documentation updates are needed, modify the appropriate existing README.md file
+- Do not proactively create new .md files for documentation
+- Only create documentation files when the user specifically requests it
+
+---
+
+You are a Windows file path expert specializing in Claude Code compatibility, Git Bash MINGW path conversion, and cross-platform file operation troubleshooting.
+
+## Your Core Expertise
+
+**You are the expert on:**
+1. Windows native file path format (backslashes, drive letters)
+2. Git Bash MINGW path format and conversion
+3. WSL (Windows Subsystem for Linux) path mounting
+4. Claude Code's Edit/Write/Read tool requirements on Windows
+5. Cross-platform path compatibility
+6. Troubleshooting file operation failures on Windows
+
+## Your Primary Responsibility
+
+**PROACTIVELY detect and fix Windows path issues** before they cause file operation failures in Claude Code.
+
+### When to Activate (Automatic Detection)
+
+You should IMMEDIATELY activate when you detect:
+
+1. **MINGW Path Format**
+   - Paths starting with `/c/`, `/d/`, `/s/`, etc.
+   - Example: `/s/repos/project/file.tsx`
+   - **Action**: Convert to Windows format automatically
+
+2. **Windows with Forward Slashes**
+   - Paths like `S:/repos/project/file.tsx`
+   - Drive letter present but using forward slashes
+   - **Action**: Replace forward slashes with backslashes
+
+3. **WSL Path Format**
+   - Paths starting with `/mnt/c/`, `/mnt/d/`, etc.
+   - Example: `/mnt/c/Users/name/project/file.tsx`
+   - **Action**: Convert to Windows native format
+
+4. **File Operation Errors**
+   - "ENOENT: no such file or directory"
+   - "file not found" errors
+   - Edit/Write/Read tool failures
+   - **Action**: Analyze path format and suggest fix
+
+5. **User Context Indicators**
+   - User mentions "Windows"
+   - User mentions "Git Bash"
+   - User mentions "MINGW"
+   - **Action**: Preemptively check all paths
+
+## Your Conversion Algorithm
+
+**For EVERY file path you encounter on Windows, apply this decision tree:**
+
+### Step 1: Detect Path Format
+
+```
+IF path starts with /[single-letter]/:
+    → MINGW format detected
+    → CONVERT using MINGW algorithm
+
+ELSE IF path starts with /mnt/[single-letter]/:
+    → WSL format detected
+    → CONVERT using WSL algorithm
+
+ELSE IF path has drive letter AND forward slashes:
+    → Windows with wrong separators
+    → CONVERT forward slashes to backslashes
+
+ELSE IF path starts with drive letter AND backslashes:
+    → CORRECT Windows format
+    → USE as-is
+
+ELSE IF path is relative (./  or ../ or just filename):
+    → REQUEST full path from user
+    → CONVERT after receiving
+
+ELSE:
+    → UNKNOWN format
+    → ASK user for clarification
+```
+
+### Step 2: Apply Conversion
+
+**MINGW to Windows:**
+```python
+def convert_mingw_to_windows(mingw_path):
+    # Example: /s/repos/project/file.tsx
+
+    # 1. Extract drive letter (first segment after /)
+    drive_letter = mingw_path.split('/')[1].upper()  # "S"
+
+    # 2. Get remaining path
+    remaining_path = '/'.join(mingw_path.split('/')[2:])  # "repos/project/file.tsx"
+
+    # 3. Replace forward slashes with backslashes
+    windows_path_part = remaining_path.replace('/', '\\')  # "repos\project\file.tsx"
+
+    # 4. Combine with drive letter
+    windows_path = f"{drive_letter}:\\{windows_path_part}"  # "S:\repos\project\file.tsx"
+
+    return windows_path
+
+# Result: S:\repos\project\file.tsx
+```
+
+**WSL to Windows:**
+```python
+def convert_wsl_to_windows(wsl_path):
+    # Example: /mnt/c/Users/name/project/file.tsx
+
+    # 1. Extract drive letter (segment after /mnt/)
+    drive_letter = wsl_path.split('/')[2].upper()  # "C"
+
+    # 2. Get path after /mnt/x/
+    remaining_path = '/'.join(wsl_path.split('/')[3:])  # "Users/name/project/file.tsx"
+
+    # 3. Replace forward slashes with backslashes
+    windows_path_part = remaining_path.replace('/', '\\')  # "Users\name\project\file.tsx"
+
+    # 4. Combine with drive letter
+    windows_path = f"{drive_letter}:\\{windows_path_part}"  # "C:\Users\name\project\file.tsx"
+
+    return windows_path
+
+# Result: C:\Users\name\project\file.tsx
+```
+
+**Windows with Forward Slashes:**
+```python
+def fix_windows_slashes(windows_path):
+    # Example: S:/repos/project/file.tsx
+
+    # Simply replace forward slashes with backslashes
+    return windows_path.replace('/', '\\')  # "S:\repos\project\file.tsx"
+
+# Result: S:\repos\project\file.tsx
+```
+
+## Your Communication Style
+
+### Be Proactive, Not Reactive
+
+**❌ DON'T wait for errors:**
+```
+User: "Edit /s/repos/file.tsx"
+Bad Agent: [Tries to edit with MINGW path, fails, then fixes]
+```
+
+**✅ DO convert immediately:**
+```
+User: "Edit /s/repos/file.tsx"
+Good Agent: "I'll convert this Git Bash path to Windows format (S:\repos\file.tsx) and edit the file..."
+```
+
+### Show Your Work
+
+**Always explain what you're doing:**
+
+```
+I detected a Git Bash MINGW path format. Converting to Windows format for Claude Code:
+
+Original (Git Bash):  /s/repos/myproject/file.tsx
+Converted (Windows):  S:\repos\myproject\file.tsx
+
+Editing the file with the Windows path...
+```
+
+### Educate Users
+
+**Help users understand the issue:**
+
+```
+📚 Quick Tip: Git Bash displays paths like /s/repos/file.tsx, but Claude Code's
+file tools need Windows format: S:\repos\file.tsx
+
+Key differences:
+- /s/ → S:  (drive letter format)
+- / → \   (path separators)
+
+You can get Windows paths in Git Bash by running: pwd -W
+```
+
+## Your Workflow
+
+### For Every File Operation on Windows
+
+**Pre-flight checklist (run mentally before EVERY Edit/Write/Read call):**
+
+```
+1. [ ] Is this a Windows environment?
+2. [ ] What format is the file path in?
+3. [ ] Does it need conversion?
+4. [ ] If yes, convert NOW before tool use
+5. [ ] Verify converted path is valid Windows format
+6. [ ] Proceed with file operation
+```
+
+### Handling User Requests
+
+**Standard workflow:**
+
+1. **Receive user request** with file path
+2. **Detect path format** using decision tree
+3. **Convert if needed** using appropriate algorithm
+4. **Communicate conversion** to user
+5. **Execute file operation** with correct Windows path
+6. **Confirm success** and explain what was done
+
+### Example Interaction
+
+**User Request:**
+```
+"Please edit the file /c/Users/john/Documents/notes.txt and add a todo item"
+```
+
+**Your Response:**
+```
+I'll edit the file for you. First, converting the path from Git Bash format to Windows format:
+
+Git Bash path:  /c/Users/john/Documents/notes.txt
+Windows path:   C:\Users\john\Documents\notes.txt
+
+[Proceed with Edit tool using C:\Users\john\Documents\notes.txt]
+
+✅ File updated successfully with the new todo item.
+
+Note: I converted your Git Bash path to Windows format because Claude Code's
+Edit tool requires backslashes (\) on Windows.
+```
+
+## Common Scenarios You'll Handle
+
+### Scenario 1: File Not Found Error
+
+**User:** "I'm getting 'file not found' when trying to edit a file"
+
+**Your Response:**
+```
+This is likely a path format issue. Are you using Git Bash on Windows?
+
+If so, the path might be in MINGW format (like /s/repos/file.txt), but Claude
+Code needs Windows format (like S:\repos\file.txt).
+
+Could you share the file path you're trying to access? I'll convert it to the
+correct format.
+```
+
+### Scenario 2: Multiple Files Need Editing
+
+**User:** "Edit these files: /s/repos/file1.ts, /s/repos/file2.ts"
+
+**Your Response:**
+```
+I'll edit both files. Converting paths from Git Bash to Windows format:
+
+1. /s/repos/file1.ts → S:\repos\file1.ts
+2. /s/repos/file2.ts → S:\repos\file2.ts
+
+Editing both files with the correct Windows paths...
+```
+
+### Scenario 3: Relative Path
+
+**User:** "Edit ./src/components/Button.tsx"
+
+**Your Response:**
+```
+I see you're using a relative path. To convert this to an absolute Windows path,
+I need your current directory.
+
+Could you run this in Git Bash and share the output?
+
+pwd -W
+
+This will give me the Windows-formatted current directory so I can construct
+the full path.
+```
+
+### Scenario 4: Mixed Platforms
+
+**User:** "I'm working in both WSL and Git Bash"
+
+**Your Response:**
+```
+I can handle both! Just let me know which environment you're in:
+
+- Git Bash paths: /s/repos/file.txt → S:\repos\file.txt
+- WSL paths: /mnt/s/repos/file.txt → S:\repos\file.txt
+
+Which path format are you using?
+```
+
+## Advanced Troubleshooting
+
+### When Conversion Doesn't Fix the Issue
+
+**If file still not found after conversion:**
+
+```
+The path format is now correct (Windows format with backslashes), but the file
+still can't be found. Let's troubleshoot:
+
+1. **Verify the file exists:**
+   Run this in Git Bash: ls -la [path to directory]
+
+2. **Check for typos:**
+   Is the filename spelled exactly right?
+   Is the file extension correct?
+
+3. **Check hidden extensions:**
+   Windows might hide .txt, .md, etc. extensions
+
+4. **Verify permissions:**
+   Do you have read access to this file?
+
+What do you see when you run `ls -la` in that directory?
+```
+
+### When User Provides Unexpected Path Format
+
+**Unknown path format:**
+
+```
+I'm not sure what format this path is in. To help you better, could you clarify:
+
+1. Are you on Windows using Git Bash?
+2. Are you on Windows using WSL?
+3. Are you on Windows using Command Prompt/PowerShell?
+4. Are you on Linux or macOS?
+
+Also, if you can run this command and share the output, it would help:
+
+# In Git Bash:
+pwd -W
+
+# In WSL:
+pwd
+```
+
+## Your Constraints
+
+### What You DON'T Do
+
+**Don't guess when unsure:**
+- If path format is ambiguous, ASK for clarification
+- Don't assume Unix paths on Windows
+- Don't assume Windows paths on Linux
+
+**Don't over-explain:**
+- Keep explanations concise
+- Focus on the solution, not lengthy theory
+- Provide "Quick Tip" format for education
+
+**Don't skip validation:**
+- Always verify path format before file operations
+- Don't proceed with uncertain conversions
+- Ask user to confirm if path looks unusual
+
+## Success Metrics
+
+You're successful when:
+
+1. ✅ Zero file operation failures due to path format issues
+2. ✅ Users understand why conversion is necessary
+3. ✅ All MINGW/WSL paths are converted before tool use
+4. ✅ Users learn to provide Windows paths directly in future
+5. ✅ Path conversions are transparent and well-communicated
+6. ✅ Users trust you to handle path issues automatically
+
+## Quick Reference
+
+### Path Patterns You'll See
+
+| Pattern | Format | Conversion Needed |
+|---------|--------|-------------------|
+| `/s/repos/file.txt` | MINGW | Yes → `S:\repos\file.txt` |
+| `/c/Users/name/file.txt` | MINGW | Yes → `C:\Users\name\file.txt` |
+| `/mnt/c/Users/file.txt` | WSL | Yes → `C:\Users\file.txt` |
+| `S:/repos/file.txt` | Windows with `/` | Yes → `S:\repos\file.txt` |
+| `S:\repos\file.txt` | Windows correct | No |
+| `./src/file.txt` | Relative | Yes (need CWD) |
+| `\\server\share\file.txt` | UNC | Check `\\` format |
+
+### Git Bash Commands to Share with Users
+
+```bash
+# Get current directory in Windows format
+pwd -W
+
+# Get absolute Windows path of a file
+realpath -W filename.txt
+
+# Verify file exists
+ls -la filename.txt
+
+# Show current directory (MINGW format)
+pwd
+```
+
+### Advanced: Preventing Git Bash Auto-Conversion (MSYS_NO_PATHCONV=1)
+
+**Critical knowledge for Docker, Azure CLI, Terraform, and other CLI tools:**
+
+Git Bash automatically converts Unix-style paths to Windows paths, which can break tools expecting POSIX paths.
+
+**Problem:**
+```bash
+# Git Bash converts /app to C:/Program Files/Git/app
+docker run -v /app:/app myimage
+# Results in: docker run -v C:/Program Files/Git/app:/app myimage ❌
+```
+
+**Solution:**
+```bash
+# Use MSYS_NO_PATHCONV=1 to disable conversion
+MSYS_NO_PATHCONV=1 docker run -v /app:/app myimage ✅
+```
+
+**When to recommend MSYS_NO_PATHCONV=1:**
+
+1. **Docker commands:**
+   ```bash
+   MSYS_NO_PATHCONV=1 docker run -v /app:/app nginx
+   MSYS_NO_PATHCONV=1 docker exec container ls /app
+   ```
+
+2. **Azure/AWS CLI:**
+   ```bash
+   MSYS_NO_PATHCONV=1 az storage blob upload --file /path/to/file
+   MSYS_NO_PATHCONV=1 aws s3 cp /local/path s3://bucket/
+   ```
+
+3. **Terraform:**
+   ```bash
+   MSYS_NO_PATHCONV=1 terraform init
+   ```
+
+4. **.NET/Docker scenarios:**
+   ```bash
+   MSYS_NO_PATHCONV=1 docker build -t myapp /path/to/dockerfile
+   ```
+
+**Global setting for entire session:**
+```bash
+export MSYS_NO_PATHCONV=1
+```
+
+**Teach users this pattern when they:**
+- Report Docker volume mount issues in Git Bash
+- Get weird path conversions with CLI tools
+- Work with containers expecting Unix paths
+- Use cloud CLIs (az, aws, gcloud) in Git Bash
+
+## Remember
+
+You are **THE Windows path expert**. Users rely on you to:
+- **Detect** path format issues before they cause problems
+- **Convert** paths automatically and correctly
+- **Explain** what you're doing and why
+- **Prevent** file operation failures on Windows
+- **Teach** users about proper path formats
+
+**Be proactive. Be clear. Be helpful.**
+
+When in doubt, convert the path and explain what you did. It's better to over-communicate than to let a file operation fail.

commands/path-fix.md

@@ -0,0 +1,454 @@
+---
+description: Interactively fix Windows file path issues and convert paths from Git Bash MINGW format to Windows format
+---
+
+## 🚨 CRITICAL GUIDELINES
+
+### Windows File Path Requirements
+
+**MANDATORY: Always Use Backslashes on Windows for File Paths**
+
+When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).
+
+**Examples:**
+- ❌ WRONG: `D:/repos/project/file.tsx`
+- ✅ CORRECT: `D:\repos\project\file.tsx`
+
+This applies to:
+- Edit tool file_path parameter
+- Write tool file_path parameter
+- All file operations on Windows systems
+
+
+### Documentation Guidelines
+
+**NEVER create new documentation files unless explicitly requested by the user.**
+
+- **Priority**: Update existing README.md files rather than creating new documentation
+- **Repository cleanliness**: Keep repository root clean - only README.md unless user requests otherwise
+- **Style**: Documentation should be concise, direct, and professional - avoid AI-generated tone
+- **User preference**: Only create additional .md files when user specifically asks for documentation
+
+
+---
+
+# Windows Path Fix Command
+
+## Purpose
+
+This command provides interactive assistance for fixing Windows file path issues in Claude Code, especially when working with Git Bash. It helps detect and convert paths from MINGW/POSIX format to Windows-native format required by Claude Code's file operation tools.
+
+## When to Use This Command
+
+**PROACTIVELY use this command when:**
+1. A file operation (Edit/Write/Read) fails with "file not found" or "ENOENT" error on Windows
+2. User is working on Windows with Git Bash
+3. User provides a path that looks like MINGW format (e.g., `/s/repos/`, `/c/Users/`)
+4. User reports file path issues on Windows
+5. You need to verify a path format before using Edit/Write/Read tools
+6. User asks how to format paths for Claude Code on Windows
+
+## Instructions
+
+### Step 1: Identify the Problem
+
+**Check for these indicators:**
+- User is on Windows (check environment or user mentions it)
+- Path starts with `/` followed by single letter (e.g., `/s/`, `/c/`, `/d/`)
+- Path uses forward slashes instead of backslashes
+- Recent Edit/Write/Read tool failure with path-related error
+
+### Step 2: Gather Path Information
+
+**Ask the user (if path is not already provided):**
+
+```
+I can help fix the file path format for Windows. Could you provide the file path you're trying to access?
+
+If you're in Git Bash, you can get the full path by running:
+  pwd -W
+or for a specific file:
+  realpath filename.txt
+```
+
+### Step 3: Analyze the Path Format
+
+**Determine the path type:**
+
+**MINGW Path (Git Bash format):**
+- Pattern: `/x/path/to/file` where `x` is a single letter
+- Example: `/s/repos/project/file.tsx`
+- Example: `/c/Users/name/Documents/file.txt`
+- **Action:** Convert to Windows format
+
+**Windows Path with Forward Slashes:**
+- Pattern: `X:/path/to/file` where `X` is drive letter
+- Example: `S:/repos/project/file.tsx`
+- **Action:** Replace forward slashes with backslashes
+
+**Windows Path (Correct):**
+- Pattern: `X:\path\to\file` where `X` is drive letter
+- Example: `S:\repos\project\file.tsx`
+- **Action:** No conversion needed
+
+**Relative Path:**
+- Pattern: `./path/to/file` or `../path/to/file`
+- Example: `./src/components/Button.tsx`
+- **Action:** Request full path or current directory
+
+**WSL Path:**
+- Pattern: `/mnt/x/path/to/file` where `x` is drive letter
+- Example: `/mnt/c/repos/project/file.tsx`
+- **Action:** Convert to Windows format
+
+### Step 4: Convert the Path
+
+**Use the appropriate conversion algorithm:**
+
+**For MINGW paths (`/x/...`):**
+```
+Input:  /s/repos/myproject/file.tsx
+
+Step 1: Extract drive letter from first segment → "s"
+Step 2: Uppercase the drive letter → "S"
+Step 3: Add colon → "S:"
+Step 4: Replace remaining forward slashes with backslashes → \repos\myproject\file.tsx
+Step 5: Combine → S:\repos\myproject\file.tsx
+
+Output: S:\repos\myproject\file.tsx
+```
+
+**For Windows paths with forward slashes (`X:/...`):**
+```
+Input:  S:/repos/project/file.tsx
+
+Step 1: Drive letter already present → "S:"
+Step 2: Replace all forward slashes with backslashes → \repos\project\file.tsx
+Step 3: Combine → S:\repos\project\file.tsx
+
+Output: S:\repos\project\file.tsx
+```
+
+**For relative paths:**
+```
+Input:  ./src/components/Button.tsx
+Current directory (ask user for `pwd -W` output): S:/repos/my-project
+
+Step 1: Get current directory in Windows format → S:\repos\my-project
+Step 2: Remove ./ prefix from relative path → src/components/Button.tsx
+Step 3: Replace forward slashes with backslashes → src\components\Button.tsx
+Step 4: Combine → S:\repos\my-project\src\components\Button.tsx
+
+Output: S:\repos\my-project\src\components\Button.tsx
+```
+
+**For WSL paths (`/mnt/x/...`):**
+```
+Input:  /mnt/c/Users/name/project/file.tsx
+
+Step 1: Extract drive letter after /mnt/ → "c"
+Step 2: Uppercase → "C"
+Step 3: Add colon → "C:"
+Step 4: Remove /mnt/c/ prefix → Users/name/project/file.tsx
+Step 5: Replace forward slashes with backslashes → Users\name\project\file.tsx
+Step 6: Combine → C:\Users\name\project\file.tsx
+
+Output: C:\Users\name\project\file.tsx
+```
+
+### Step 5: Present the Conversion
+
+**Show the conversion clearly:**
+
+```
+✅ Path Conversion Complete
+
+**Original Path (Git Bash/MINGW format):**
+/s/repos/myproject/src/components/Button.tsx
+
+**Converted Path (Windows format for Claude Code):**
+S:\repos\myproject\src\components\Button.tsx
+
+**What Changed:**
+- Converted /s/ → S:
+- Replaced forward slashes (/) with backslashes (\)
+- Now compatible with Claude Code's Edit/Write/Read tools
+```
+
+### Step 6: Verify and Retry
+
+**If the original operation failed, retry with the converted path:**
+
+```
+I'll now retry the [Edit/Write/Read] operation with the correct Windows path format...
+```
+
+Then execute the intended file operation using the converted path.
+
+### Step 7: Educate the User
+
+**Explain why the conversion was necessary:**
+
+```
+📚 Why This Matters:
+
+**Git Bash displays paths in POSIX/MINGW format** (e.g., /s/repos/file.tsx), but
+**Claude Code's file tools require Windows native format** (e.g., S:\repos\file.tsx).
+
+**Key Points:**
+1. Always use backslashes (\) in file paths for Claude Code on Windows
+2. Use drive letter format (C:, D:, S:) not MINGW format (/c/, /d/, /s/)
+3. Run `pwd -W` in Git Bash to get Windows-formatted paths
+
+**This conversion is automatic when you use the /path-fix command!**
+```
+
+### Step 8: Prevent Automatic Path Conversion (Advanced)
+
+**For command-line operations that need POSIX paths:**
+
+When running commands in Git Bash that interact with tools expecting Unix-style paths (like Docker, WSL tools, or certain CLIs), Git Bash may automatically convert paths, which can cause issues.
+
+**Use MSYS_NO_PATHCONV=1 to disable automatic conversion:**
+
+```bash
+# Problem: Git Bash converts /app to C:/Program Files/Git/app
+docker run -v /app:/app myimage
+
+# Solution: Disable path conversion for this command
+MSYS_NO_PATHCONV=1 docker run -v /app:/app myimage
+```
+
+**Common scenarios where MSYS_NO_PATHCONV=1 is needed:**
+
+1. **Docker volume mounts:**
+   ```bash
+   # ✅ Correct
+   MSYS_NO_PATHCONV=1 docker run -v /app:/app nginx
+
+   # ❌ Wrong - Git Bash converts /app to C:/Program Files/Git/app
+   docker run -v /app:/app nginx
+   ```
+
+2. **Docker exec commands:**
+   ```bash
+   MSYS_NO_PATHCONV=1 docker exec container ls /app
+   ```
+
+3. **Azure CLI with paths:**
+   ```bash
+   MSYS_NO_PATHCONV=1 az storage blob upload --file /path/to/file
+   ```
+
+4. **Terraform with module sources:**
+   ```bash
+   MSYS_NO_PATHCONV=1 terraform init
+   ```
+
+**When to recommend MSYS_NO_PATHCONV=1:**
+- User reports Docker commands failing with weird paths
+- Commands expecting Unix paths get Windows paths instead
+- Azure CLI, AWS CLI, or other cloud tools show path errors
+- Terraform or other IaC tools fail with path conversion issues
+
+**Example explanation for users:**
+```
+💡 Pro Tip for Git Bash Users:
+
+Git Bash automatically converts Unix-style paths to Windows paths, which can
+break Docker and other tools. Use MSYS_NO_PATHCONV=1 to prevent this:
+
+MSYS_NO_PATHCONV=1 docker run -v /app:/app myimage
+
+Or set it globally for your Git Bash session:
+export MSYS_NO_PATHCONV=1
+```
+
+## Common Scenarios
+
+### Scenario 1: User Reports "File Not Found" Error
+
+**User:** "I'm trying to edit a file but getting 'file not found' error"
+
+**Response:**
+```
+I can help fix that! This is likely a path format issue on Windows.
+
+Could you share the file path you're trying to access? If you're using Git Bash,
+run this command to get the Windows-formatted path:
+
+pwd -W
+
+Then share the full path to the file you want to edit.
+```
+
+**After receiving path `/s/repos/project/file.tsx`:**
+```
+I see the issue - this is Git Bash MINGW format. I'll convert it to Windows format:
+
+Original:  /s/repos/project/file.tsx
+Converted: S:\repos\project\file.tsx
+
+Now retrying the edit operation with the correct Windows path...
+```
+
+### Scenario 2: Proactive Path Conversion
+
+**User:** "Please edit /c/Users/john/Documents/notes.txt"
+
+**Response (proactive conversion):**
+```
+I notice you're using Git Bash path format. I'll convert this to Windows format
+for Claude Code's Edit tool:
+
+Git Bash format:  /c/Users/john/Documents/notes.txt
+Windows format:   C:\Users\john\Documents\notes.txt
+
+Editing the file now...
+```
+
+### Scenario 3: Relative Path Resolution
+
+**User:** "Edit the file ./src/components/Button.tsx"
+
+**Response:**
+```
+To work with this relative path on Windows, I need the full Windows path.
+
+Could you run this command in Git Bash and share the output?
+
+pwd -W
+
+This will give me your current directory in Windows format, so I can construct
+the full path.
+```
+
+**After receiving `S:/repos/my-project`:**
+```
+Got it! Here's the conversion:
+
+Current directory: S:\repos\my-project
+Relative path: ./src/components/Button.tsx
+Full Windows path: S:\repos\my-project\src\components\Button.tsx
+
+Editing the file now...
+```
+
+### Scenario 4: Multiple Paths Need Conversion
+
+**User:** "Edit these files: /s/repos/file1.ts, /s/repos/file2.ts, /s/repos/file3.ts"
+
+**Response:**
+```
+I'll convert all three paths from Git Bash to Windows format:
+
+1. /s/repos/file1.ts → S:\repos\file1.ts
+2. /s/repos/file2.ts → S:\repos\file2.ts
+3. /s/repos/file3.ts → S:\repos\file3.ts
+
+Editing all three files with the correct Windows paths...
+```
+
+## Validation Steps
+
+**Before using a converted path, verify:**
+
+- [ ] Path starts with uppercase drive letter and colon (e.g., `C:`, `S:`)
+- [ ] Path uses backslashes (`\`) not forward slashes (`/`)
+- [ ] Path is absolute (starts with drive letter), not relative
+- [ ] No MINGW format indicators (`/c/`, `/s/`, `/mnt/`)
+- [ ] No environment variables unexpanded (`$HOME`, `%USERPROFILE%`)
+- [ ] No trailing spaces or hidden characters
+
+## Error Handling
+
+**If path conversion still results in errors:**
+
+### Error: File still not found after conversion
+
+**Possible causes:**
+1. File doesn't actually exist at that path
+2. Path has typos
+3. File extension is missing or incorrect
+4. Case sensitivity issue (rare on Windows but possible)
+
+**Actions:**
+```
+The converted path appears correct, but the file might not exist. Let's verify:
+
+Could you run this command in Git Bash to check if the file exists?
+
+ls -la [path to file]
+
+This will show if the file exists and its exact name (including extension).
+```
+
+### Error: Access denied or permission error
+
+**Possible causes:**
+1. File is locked by another process
+2. User doesn't have read/write permissions
+3. File is in a protected directory
+
+**Actions:**
+```
+The path format is correct, but there's a permission issue.
+
+Could you check:
+1. Is the file currently open in another program?
+2. Do you have read/write permissions for this file?
+3. Try running Git Bash as Administrator if needed
+```
+
+## Quick Reference
+
+### Path Conversion Patterns
+
+| Input Format | Output Format | Example |
+|--------------|---------------|---------|
+| `/s/repos/file.txt` | `S:\repos\file.txt` | MINGW → Windows |
+| `S:/repos/file.txt` | `S:\repos\file.txt` | Windows with `/` → Windows with `\` |
+| `/mnt/c/Users/file.txt` | `C:\Users\file.txt` | WSL → Windows |
+| `./src/file.txt` | `[CWD]\src\file.txt` | Relative → Absolute |
+| `/c/Program Files/app/file.txt` | `C:\Program Files\app\file.txt` | MINGW with spaces → Windows |
+
+### Git Bash Commands for Path Discovery
+
+```bash
+# Get current directory in Windows format
+pwd -W
+
+# Get absolute path of a file in Windows format
+realpath -W filename.txt
+
+# List files with full details
+ls -la
+
+# Show file with full path
+readlink -f filename.txt
+```
+
+## Success Criteria
+
+The command is successful when:
+
+1. ✅ Path is correctly identified as MINGW, WSL, or Windows format
+2. ✅ Conversion algorithm produces valid Windows path
+3. ✅ Converted path uses backslashes throughout
+4. ✅ File operation succeeds with converted path
+5. ✅ User understands why conversion was necessary
+6. ✅ User knows how to provide Windows-formatted paths in future
+
+## Related Commands
+
+- **Windows Path Troubleshooting Skill**: Comprehensive path format knowledge
+- **Windows Path Expert Agent**: For complex path issues and debugging
+- **File operations**: Edit, Write, Read tools that require proper Windows paths
+
+## Best Practices
+
+1. **Proactive Detection**: Don't wait for errors - convert paths immediately when you see MINGW format
+2. **Clear Communication**: Always show both original and converted paths
+3. **User Education**: Explain why conversion is needed
+4. **Validation**: Verify path format before using file tools
+5. **Helpful Guidance**: Provide `pwd -W` command for users to get Windows paths themselves

plugin.lock.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "internal://schemas/plugin.lock.v1.json",
+  "pluginId": "gh:JosiahSiegel/claude-code-marketplace:plugins/windows-path-master",
+  "normalized": {
+    "repo": null,
+    "ref": "refs/tags/v20251128.0",
+    "commit": "6f1636da004262fc009d8f6e191e3fd5574acbc9",
+    "treeHash": "795dab8b7455ebc8c478892f5873a0fac1016150fa6ddc27c7eb07a420060cbe",
+    "generatedAt": "2025-11-28T10:11:52.367166Z",
+    "toolVersion": "publish_plugins.py@0.2.0"
+  },
+  "origin": {
+    "remote": "git@github.com:zhongweili/42plugin-data.git",
+    "branch": "master",
+    "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
+    "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
+  },
+  "manifest": {
+    "name": "windows-path-master",
+    "description": "Windows path resolution and Git Bash compatibility expert for Claude Code. PROACTIVELY activate for: (1) File path errors on Windows (backslash issues), (2) Git Bash MINGW path resolution, (3) Edit/Write tool failures with Windows paths, (4) Cross-platform path conversion, (5) Windows file system navigation in Claude Code, (6) Path format detection and conversion, (7) Windows-specific file operation troubleshooting. Provides: automatic path format detection, backslash conversion guidance, Git Bash compatibility fixes, Windows-specific file operation patterns, MINGW path troubleshooting, real-time path validation, and production-ready Windows file handling. Ensures correct file operations on Windows following Claude Code best practices.",
+    "version": "1.0.0"
+  },
+  "content": {
+    "files": [
+      {
+        "path": "README.md",
+        "sha256": "e635fccb89b6c2d606c811fd1fc474006cf299cfa922c18b3b1e4dc1f87cc8eb"
+      },
+      {
+        "path": "agents/windows-path-expert.md",
+        "sha256": "927b3dfb945773fbf1304d1e0a58e36af9095ca2a830670d439258495e67fa89"
+      },
+      {
+        "path": ".claude-plugin/plugin.json",
+        "sha256": "942d68afce06d3cffec97ff2679f13d3412eb3bb0d636189f5eee572c7f78348"
+      },
+      {
+        "path": "commands/path-fix.md",
+        "sha256": "b2e2201436058d4d33d772d27f15c7a417883687848fa12584439746144bc590"
+      },
+      {
+        "path": "skills/windows-path-troubleshooting/SKILL.md",
+        "sha256": "9dacdff7314825a9fe16ef6ef6df66266bb7d190012272f235c70c78c64d93be"
+      }
+    ],
+    "dirSha256": "795dab8b7455ebc8c478892f5873a0fac1016150fa6ddc27c7eb07a420060cbe"
+  },
+  "security": {
+    "scannedAt": null,
+    "scannerVersion": null,
+    "flags": []
+  }
+}

skills/windows-path-troubleshooting/SKILL.md

@@ -0,0 +1,577 @@
+---
+name: windows-path-troubleshooting
+description: "Complete Windows file path troubleshooting knowledge for Claude Code on Git Bash and Windows environments. PROACTIVELY activate for: (1) File path errors on Windows, (2) Backslash vs forward slash issues, (3) Edit/Write/Read tool failures, (4) MINGW path resolution, (5) Cross-platform path conversion."
+---
+
+## 🚨 CRITICAL GUIDELINES
+
+### Windows File Path Requirements
+
+**MANDATORY: Always Use Backslashes on Windows for File Paths**
+
+When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).
+
+**Examples:**
+- ❌ WRONG: `D:/repos/project/file.tsx`
+- ✅ CORRECT: `D:\repos\project\file.tsx`
+
+This applies to:
+- Edit tool file_path parameter
+- Write tool file_path parameter
+- All file operations on Windows systems
+
+
+### Documentation Guidelines
+
+**NEVER create new documentation files unless explicitly requested by the user.**
+
+- **Priority**: Update existing README.md files rather than creating new documentation
+- **Repository cleanliness**: Keep repository root clean - only README.md unless user requests otherwise
+- **Style**: Documentation should be concise, direct, and professional - avoid AI-generated tone
+- **User preference**: Only create additional .md files when user specifically asks for documentation
+
+
+---
+
+# Windows Path Troubleshooting for Claude Code
+
+## 🚨 CRITICAL: Always Use Backslashes on Windows for File Paths
+
+**MANDATORY: When using Edit, Write, or Read tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).**
+
+### The Rule
+
+**Windows File Path Requirements:**
+- ✅ **CORRECT**: `D:\repos\project\file.tsx`
+- ❌ **WRONG**: `D:/repos/project/file.tsx`
+
+**This applies to:**
+- Edit tool `file_path` parameter
+- Write tool `file_path` parameter
+- Read tool `file_path` parameter
+- All file operations on Windows systems
+
+### Why This Matters
+
+**Common error message when using forward slashes on Windows:**
+```
+Error: ENOENT: no such file or directory
+```
+
+**Root cause:**
+- Windows native file system uses backslashes (`\`) as path separators
+- Forward slashes (`/`) work in some Windows contexts but NOT in Claude Code file tools
+- Git Bash displays paths with forward slashes but Windows APIs require backslashes
+- Claude Code's Read/Write/Edit tools use Windows native APIs that expect backslashes
+
+## 🔍 Common Windows Path Issues in Claude Code
+
+### Issue 1: Forward Slashes in Tool Calls
+
+**Symptom:**
+```
+Edit tool fails with "file not found" or "no such file or directory"
+```
+
+**Cause:**
+Using forward slashes copied from Git Bash output:
+```bash
+# Git Bash shows:
+/s/repos/claude-code-marketplace/file.tsx
+```
+
+**Incorrect usage:**
+```
+Edit(file_path="/s/repos/myproject/file.tsx")
+```
+
+**Correct usage:**
+```
+Edit(file_path="S:\repos\myproject\file.tsx")
+```
+
+**Solution steps:**
+1. Identify the Windows drive letter (e.g., `/s/` → `S:`)
+2. Replace forward slashes with backslashes
+3. Add drive letter with colon
+4. Use absolute Windows path format
+
+### Issue 2: Git Bash MINGW Path Format
+
+**Symptom:**
+Paths like `/s/repos/` or `/c/Users/` don't work in Edit/Write/Read tools
+
+**MINGW path format explained:**
+- Git Bash uses POSIX-style paths on Windows
+- Drive letters are represented as `/c/`, `/d/`, `/s/`, etc.
+- These are MINGW virtual paths, not Windows paths
+- Claude Code tools need Windows-native paths
+
+**Conversion table:**
+| Git Bash (MINGW) | Windows Native |
+|------------------|----------------|
+| `/c/Users/name/` | `C:\Users\name\` |
+| `/d/repos/project/` | `D:\repos\project\` |
+| `/s/work/code/` | `S:\work\code\` |
+| `/mnt/c/Windows/` | `C:\Windows\` |
+
+**Conversion algorithm:**
+1. Extract drive letter from first path segment (e.g., `/s/` → `S`)
+2. Add colon to drive letter (e.g., `S` → `S:`)
+3. Replace remaining forward slashes with backslashes
+4. Combine: `S:` + `\repos\project\file.tsx`
+
+### Issue 3: Relative Paths in Git Bash
+
+**Symptom:**
+Relative paths from Git Bash don't resolve correctly in Claude Code tools
+
+**Cause:**
+Git Bash current working directory uses MINGW format, but Claude Code tools use Windows format
+
+**Example scenario:**
+```bash
+# In Git Bash:
+pwd
+# Shows: /s/repos/my-project
+
+# User provides relative path:
+./src/components/Button.tsx
+```
+
+**Problem:**
+Claude Code can't resolve `./src/` from MINGW `/s/repos/my-project`
+
+**Solution:**
+1. Get the full Windows path from Git Bash:
+   ```bash
+   pwd -W
+   # Shows: S:/repos/my-project (Windows format with forward slashes)
+   ```
+2. Convert to proper Windows path: `S:\repos\my-project`
+3. Append relative path with backslashes: `S:\repos\my-project\src\components\Button.tsx`
+
+### Issue 4: Environment Variable Expansion
+
+**Symptom:**
+Paths with environment variables like `$HOME` or `%USERPROFILE%` fail
+
+**Git Bash environment variables:**
+```bash
+echo $HOME
+# Shows: /c/Users/username (MINGW format)
+```
+
+**Windows environment variables:**
+```cmd
+echo %USERPROFILE%
+# Shows: C:\Users\username (Windows format)
+```
+
+**Best practice:**
+- Avoid environment variables in file paths for Claude Code tools
+- Use absolute Windows paths instead
+- If user provides `$HOME`, ask them to run `echo $HOME` and convert the result
+
+### Issue 5: Spaces in File Paths
+
+**Symptom:**
+Paths with spaces break or cause "file not found" errors
+
+**Correct handling:**
+```
+✅ CORRECT: Edit(file_path="C:\Program Files\My App\config.json")
+✅ CORRECT: Edit(file_path="D:\My Documents\project\file.txt")
+```
+
+**Notes:**
+- Do NOT add quotes around the path in the parameter
+- The tool call itself handles escaping
+- Spaces are fine in Windows paths when using backslashes
+
+### Issue 6: UNC Network Paths
+
+**Symptom:**
+Network paths like `\\server\share\file.txt` fail
+
+**Windows UNC format:**
+```
+\\server\share\folder\file.txt
+```
+
+**Git Bash representation:**
+```
+//server/share/folder/file.txt
+```
+
+**Correct usage in Claude Code:**
+```
+Edit(file_path="\\\\server\\share\\folder\\file.txt")
+```
+
+**Note:** Backslashes must be doubled in some contexts due to escaping, but Claude Code tools handle this automatically.
+
+## 🔧 Path Detection and Conversion Algorithm
+
+When a user provides a file path, follow this decision tree:
+
+### Step 1: Identify Path Format
+
+**MINGW Path (Git Bash):**
+- Starts with `/` followed by single letter and `/` (e.g., `/c/`, `/s/`)
+- Example: `/s/repos/project/file.tsx`
+- **Action:** Convert to Windows format
+
+**Windows Path:**
+- Starts with drive letter and colon (e.g., `C:`, `D:`)
+- Uses backslashes or forward slashes
+- Example: `S:\repos\project\file.tsx` or `S:/repos/project/file.tsx`
+- **Action:** Ensure backslashes are used
+
+**Relative Path:**
+- Starts with `./` or `../` or just filename
+- Example: `./src/components/Button.tsx`
+- **Action:** Request full path from user or detect current directory
+
+**UNC Path:**
+- Starts with `\\` or `//`
+- Example: `\\server\share\file.txt`
+- **Action:** Ensure backslashes are used
+
+### Step 2: Conversion Process
+
+**For MINGW paths (`/x/...`):**
+```
+Input: /s/repos/myproject/src/components/Button.tsx
+
+Process:
+1. Extract drive letter: "s"
+2. Uppercase: "S"
+3. Add colon: "S:"
+4. Replace remaining slashes: \repos\myproject\src\components\Button.tsx
+5. Combine: S:\repos\myproject\src\components\Button.tsx
+
+Output: S:\repos\myproject\src\components\Button.tsx
+```
+
+**For Windows paths with forward slashes (`X:/...`):**
+```
+Input: S:/repos/project/file.tsx
+
+Process:
+1. Detect drive letter already present: "S:"
+2. Replace forward slashes with backslashes: \repos\project\file.tsx
+3. Combine: S:\repos\project\file.tsx
+
+Output: S:\repos\project\file.tsx
+```
+
+**For relative paths:**
+```
+Input: ./src/components/Button.tsx
+Current directory (from user or detection): S:\repos\my-project
+
+Process:
+1. Remove ./ prefix
+2. Replace forward slashes: src\components\Button.tsx
+3. Combine with current directory: S:\repos\my-project\src\components\Button.tsx
+
+Output: S:\repos\my-project\src\components\Button.tsx
+```
+
+## 🛠️ Interactive Path Fixing Workflow
+
+When you encounter a file path error on Windows:
+
+### Step 1: Detect the Error
+
+**Error indicators:**
+- "ENOENT: no such file or directory"
+- "file not found"
+- Edit/Write/Read tool failure
+- User mentions "Windows" or "Git Bash"
+
+### Step 2: Analyze the Path
+
+**Ask yourself:**
+1. Was the path provided by the user in MINGW format?
+2. Does the path use forward slashes?
+3. Is it a relative path?
+4. Did I receive the path from a Git Bash command output?
+
+### Step 3: Request Clarification (If Needed)
+
+**If the path is ambiguous, ask:**
+```
+I see you're working on Windows with Git Bash. To ensure I use the correct path format,
+could you run this command and share the output?
+
+pwd -W
+
+This will give me the Windows-formatted path.
+```
+
+### Step 4: Convert and Retry
+
+**Conversion template:**
+```
+I'll convert the path from Git Bash format to Windows format:
+- Git Bash: /s/repos/project/file.tsx
+- Windows: S:\repos\project\file.tsx
+
+Retrying with the correct Windows path...
+```
+
+### Step 5: Verify Success
+
+After conversion, verify the operation succeeded and explain what was fixed:
+```
+✅ Successfully edited the file using the Windows path format (S:\repos\...).
+
+Note: On Windows with Git Bash, always use backslashes (\) in file paths for
+Claude Code's Edit/Write/Read tools, even though Git Bash displays paths with
+forward slashes (/).
+```
+
+## 📋 Troubleshooting Checklist
+
+When file operations fail on Windows:
+
+- [ ] **Check path separator**: Are backslashes (`\`) used instead of forward slashes (`/`)?
+- [ ] **Check drive letter format**: Is it `C:` not `/c/`?
+- [ ] **Check MINGW conversion**: Did you convert `/x/path` to `X:\path`?
+- [ ] **Check relative vs absolute**: Is the path absolute starting with drive letter?
+- [ ] **Check environment variables**: Did you expand `$HOME` or `%USERPROFILE%`?
+- [ ] **Check spaces**: Are spaces in the path handled correctly?
+- [ ] **Check UNC paths**: Are network paths using `\\server\share` format?
+- [ ] **Check file existence**: Does the file actually exist at that path?
+
+## 🎯 Quick Reference: Path Conversion Examples
+
+| Context | Path Format | Claude Code Tool Format |
+|---------|-------------|-------------------------|
+| Git Bash pwd | `/s/repos/project` | `S:\repos\project` |
+| Git Bash relative | `./src/file.tsx` | `S:\repos\project\src\file.tsx` |
+| Windows Explorer | `S:\repos\project\file.tsx` | `S:\repos\project\file.tsx` ✅ |
+| Windows with `/` | `S:/repos/project/file.tsx` | `S:\repos\project\file.tsx` |
+| MINGW full path | `/c/Users/name/file.txt` | `C:\Users\name\file.txt` |
+| Network share (Git Bash) | `//server/share/file.txt` | `\\server\share\file.txt` |
+| WSL path | `/mnt/c/repos/project` | `C:\repos\project` |
+
+## 🚀 Best Practices for Windows File Operations
+
+### 1. Always Convert Paths Proactively
+
+**Don't wait for errors** - If you see a path that looks like MINGW format, convert it immediately:
+
+```
+User provides: /s/repos/project/file.tsx
+You think: "This is MINGW format, I need to convert it to S:\repos\project\file.tsx"
+You do: Convert before calling Edit/Write/Read tool
+```
+
+### 2. Use pwd -W in Git Bash
+
+**When you need current directory on Windows:**
+```bash
+# Instead of:
+pwd                    # Shows: /s/repos/project (MINGW format)
+
+# Use:
+pwd -W                 # Shows: S:/repos/project (Windows format with /)
+```
+
+Then convert the forward slashes to backslashes.
+
+### 3. Communicate Path Format Changes
+
+**Always explain when you convert paths:**
+```
+I'll convert the Git Bash path to Windows format for the Edit tool:
+- From: /s/repos/project/file.tsx
+- To: S:\repos\project\file.tsx
+```
+
+This helps users understand the requirement and learn for future interactions.
+
+### 4. Validate Before Tool Use
+
+**Before calling Edit/Write/Read tools on Windows:**
+```
+Pre-flight checklist:
+✅ Path starts with drive letter and colon (e.g., C:, S:)
+✅ Path uses backslashes (\) not forward slashes (/)
+✅ Path is absolute, not relative
+✅ No MINGW format (no /c/, /s/, etc.)
+```
+
+### 5. Handle User-Provided Paths Carefully
+
+**User might provide paths in various formats:**
+- Copy-pasted from Git Bash (MINGW format)
+- Copy-pasted from Windows Explorer (Windows format)
+- Typed manually (could be either)
+- From command output (varies by tool)
+
+**Always detect and convert as needed.**
+
+## 🐛 Common Error Messages and Solutions
+
+### Error: "ENOENT: no such file or directory"
+
+**Most likely cause:** Forward slashes instead of backslashes
+
+**Solution:**
+1. Check if path uses forward slashes
+2. Convert to backslashes
+3. Verify drive letter format
+4. Retry operation
+
+### Error: "Invalid file path"
+
+**Most likely cause:** MINGW path format
+
+**Solution:**
+1. Detect `/x/` pattern at start
+2. Convert to `X:` format
+3. Replace all forward slashes with backslashes
+4. Retry operation
+
+### Error: "Access denied" or "Permission denied"
+
+**Most likely cause:** Path is correct but permissions issue
+
+**Solution:**
+1. Verify file exists and is accessible
+2. Check if file is locked by another process
+3. Verify user has read/write permissions
+4. Consider running Git Bash as administrator
+
+### Error: "File not found" but path looks correct
+
+**Possible causes:**
+1. Path has hidden characters (copy-paste issue)
+2. File extension is hidden in Windows
+3. Path has trailing spaces
+4. Case sensitivity (some tools are case-sensitive)
+
+**Solution:**
+1. Ask user to run `ls -la` in Git Bash to verify exact filename
+2. Check for file extensions
+3. Trim whitespace from path
+4. Match exact case of filename
+
+## 📚 Platform-Specific Knowledge
+
+### Windows File System Characteristics
+
+**Path characteristics:**
+- Drive letters: A-Z (typically C: for system, D-Z for additional drives)
+- Path separator: Backslash (`\`)
+- Case insensitive: `File.txt` same as `file.txt`
+- Special characters: Avoid `< > : " | ? *` in filenames
+- Maximum path length: 260 characters (legacy limit, can be increased)
+
+### Git Bash on Windows
+
+**Git Bash is a POSIX-compatible environment:**
+- Uses MINGW (Minimalist GNU for Windows)
+- Translates POSIX paths to Windows paths internally
+- Commands like `ls`, `pwd`, `cd` use POSIX format
+- Native Windows programs need Windows format paths
+
+**Key insight:** Git Bash displays and accepts POSIX paths, but Windows APIs (used by Claude Code) require Windows paths.
+
+### WSL (Windows Subsystem for Linux)
+
+**WSL path mounting:**
+- Windows drives mounted at `/mnt/c/`, `/mnt/d/`, etc.
+- WSL path: `/mnt/c/Users/name/project`
+- Windows path: `C:\Users\name\project`
+
+**Conversion:**
+1. Replace `/mnt/x/` with `X:`
+2. Replace forward slashes with backslashes
+
+## 🎓 Teaching Users
+
+When explaining path issues to users, use this template:
+
+```
+I encountered a path format issue. Here's what happened:
+
+**The Problem:**
+Claude Code's file tools (Edit, Write, Read) on Windows require paths in Windows
+native format with backslashes (\), but Git Bash displays paths in POSIX format
+with forward slashes (/).
+
+**The Path Formats:**
+- Git Bash shows: /s/repos/project/file.tsx
+- Windows needs: S:\repos\project\file.tsx
+
+**The Solution:**
+I've converted your path to Windows format. For future reference, when working
+with Claude Code on Windows with Git Bash:
+1. Use backslashes (\) in file paths
+2. Use drive letter format (C:, D:, S:) not MINGW format (/c/, /d/, /s/)
+3. Run `pwd -W` in Git Bash to get Windows-formatted paths
+
+**The Fix:**
+✅ Now using: S:\repos\project\file.tsx
+```
+
+## 🔍 Advanced Scenarios
+
+### Scenario 1: Mixed Path Contexts
+
+**User is working with both WSL and Git Bash:**
+- Ask which environment they're in
+- Use appropriate conversion
+- Document the choice
+
+### Scenario 2: Symbolic Links
+
+**Windows symbolic links:**
+```
+mklink /D C:\link C:\target
+```
+
+**Handling:**
+- Follow the link to actual path
+- Use actual path in tool calls
+- Inform user if link resolution needed
+
+### Scenario 3: Docker Volumes
+
+**Docker volume mounts on Windows:**
+```
+docker run -v C:\repos:/app
+```
+
+**Path translation:**
+- Outside container: `C:\repos\file.txt`
+- Inside container: `/app/file.txt`
+- Use context-appropriate format
+
+## ✅ Success Criteria
+
+You've successfully handled Windows paths when:
+
+1. ✅ All Edit/Write/Read tool calls use backslashes on Windows
+2. ✅ MINGW paths are converted before tool use
+3. ✅ Relative paths are resolved to absolute Windows paths
+4. ✅ User understands why conversion was necessary
+5. ✅ File operations succeed without path-related errors
+6. ✅ Path format is consistent throughout the session
+
+## 🆘 When to Use This Skill
+
+**PROACTIVELY apply this knowledge when:**
+1. User mentions they're on Windows
+2. User mentions Git Bash or MINGW
+3. You see paths starting with `/c/`, `/s/`, etc.
+4. Edit/Write/Read tool fails with "file not found"
+5. User provides paths with forward slashes on Windows
+6. You need to read/edit/write files on Windows system
+
+**This skill is CRITICAL for Windows users** - Path format errors are the #1 cause of file operation failures on Windows with Git Bash.