geminize 1.0.0 → 1.1.0

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-complexity-determination.mdc

@@ -0,0 +1,60 @@
+---
+description: Visual process map for VAN mode complexity determination
+globs: van-complexity-determination.mdc
+alwaysApply: false
+---
+# VAN MODE: EARLY COMPLEXITY DETERMINATION
+
+> **TL;DR:** Analyzes the task to determine complexity level. For Level 1, VAN mode completes. For Levels 2-4, triggers a mandatory switch to PLAN mode.
+
+## 🧩 COMPLEXITY DETERMINATION PROCESS
+
+```mermaid
+graph TD
+    CD["Complexity<br>Determination"] --> AnalyzeTask["Analyze Task<br>Requirements"]
+    
+    AnalyzeTask --> CheckKeywords["Check Task<br>Keywords"]
+    CheckKeywords --> ScopeCheck["Assess<br>Scope Impact"]
+    ScopeCheck --> RiskCheck["Evaluate<br>Risk Level"]
+    RiskCheck --> EffortCheck["Estimate<br>Implementation Effort"]
+    
+    EffortCheck --> DetermineLevel{"Determine<br>Complexity Level"}
+    DetermineLevel -->|"Level 1"| L1["Level 1:<br>Quick Bug Fix"]
+    DetermineLevel -->|"Level 2"| L2["Level 2:<br>Simple Enhancement"]
+    DetermineLevel -->|"Level 3"| L3["Level 3:<br>Intermediate Feature"]
+    DetermineLevel -->|"Level 4"| L4["Level 4:<br>Complex System"]
+    
+    L1 --> CDComplete["Complexity Determination<br>Complete (Level 1)"]
+    L2 & L3 & L4 --> ModeSwitch["Force Mode Switch<br>to PLAN"]
+    
+    style CD fill:#4da6ff,stroke:#0066cc,color:white
+    style CDComplete fill:#10b981,stroke:#059669,color:white
+    style ModeSwitch fill:#ff0000,stroke:#990000,color:white
+    style DetermineLevel fill:#f6546a,stroke:#c30052,color:white
+```
+
+## 🚨 MODE TRANSITION TRIGGER (VAN to PLAN)
+
+If complexity is determined to be Level 2, 3, or 4:
+
+```
+🚫 LEVEL [2-4] TASK DETECTED
+Implementation in VAN mode is BLOCKED
+This task REQUIRES PLAN mode
+You MUST switch to PLAN mode for proper documentation and planning
+Type 'PLAN' to switch to planning mode
+```
+
+## 📋 CHECKPOINT VERIFICATION TEMPLATE (Example)
+
+```
+✓ SECTION CHECKPOINT: COMPLEXITY DETERMINATION
+- Task Analyzed? [YES/NO]
+- Complexity Level Determined? [YES/NO]
+
+→ If Level 1: Proceed to VAN Mode Completion.
+→ If Level 2-4: Trigger PLAN Mode transition.
+```
+
+**Next Step (Level 1):** Complete VAN Initialization (e.g., initialize Memory Bank if needed).
+**Next Step (Level 2-4):** Exit VAN mode and initiate PLAN mode. 

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-file-verification.mdc

@@ -0,0 +1,49 @@
+---
+description: Visual process map for VAN mode file verification
+globs: van-file-verification.mdc
+alwaysApply: false
+---
+# VAN MODE: FILE VERIFICATION
+
+> **TL;DR:** Checks for the existence and basic structure of essential Memory Bank and documentation components.
+
+## 📁 FILE VERIFICATION PROCESS
+
+```mermaid
+graph TD
+    FV["File Verification"] --> CheckFiles["Check Essential Files"]
+    CheckFiles --> CheckMB["Check Memory Bank<br>Structure"]
+    CheckMB --> MBExists{"Memory Bank<br>Exists?"}
+    
+    MBExists -->|"Yes"| VerifyMB["Verify Memory Bank<br>Contents (Basic)"]
+    MBExists -->|"No"| CreateMB["Create Memory Bank<br>Structure (Basic)"]
+    
+    CheckFiles --> CheckDocs["Check Documentation<br>Files (e.g., tasks.md)"]
+    CheckDocs --> DocsExist{"Docs<br>Exist?"}
+    
+    DocsExist -->|"Yes"| VerifyDocs["Verify Documentation<br>Presence"]
+    DocsExist -->|"No"| CreateDocs["Create Essential<br>Documentation Files"]
+    
+    VerifyMB & CreateMB --> MBCP["Memory Bank<br>Checkpoint"]
+    VerifyDocs & CreateDocs --> DocsCP["Documentation<br>Checkpoint"]
+    
+    MBCP & DocsCP --> FileComplete["File Verification<br>Complete"]
+    
+    style FV fill:#4da6ff,stroke:#0066cc,color:white
+    style FileComplete fill:#10b981,stroke:#059669,color:white
+    style MBCP fill:#f6546a,stroke:#c30052,color:white
+    style DocsCP fill:#f6546a,stroke:#c30052,color:white
+```
+
+## 📋 CHECKPOINT VERIFICATION TEMPLATE (Example)
+
+```
+✓ SECTION CHECKPOINT: FILE VERIFICATION
+- Memory Bank Directory Exists/Created? [YES/NO]
+- Essential Docs (tasks.md) Exist/Created? [YES/NO]
+
+→ If all YES: File Verification Complete.
+→ If any NO: Resolve before proceeding.
+```
+
+**Next Step:** Load and process `van-complexity-determination.mdc`. 

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-mode-map.mdc

@@ -0,0 +1,49 @@
+---
+description: Visual process map for VAN mode (Index/Entry Point)
+globs: van-mode-map.mdc
+alwaysApply: false
+---
+# VAN MODE: INITIALIZATION PROCESS MAP (INDEX)
+
+> **TL;DR:** This is the entry point for VAN mode. It handles initial activation and directs the process to subsequent steps stored in separate files for optimization.
+
+## 🚀 VAN MODE ACTIVATION
+
+When the user types "VAN", respond with a confirmation and start the process:
+
+```
+User: VAN
+
+Response: OK VAN - Beginning Initialization Process
+Loading Platform Detection map...
+```
+
+## 🧭 VAN MODE PROCESS FLOW (High Level)
+
+This graph shows the main stages. Each stage is detailed in a separate file loaded sequentially.
+
+```mermaid
+graph TD
+    Start["START VAN MODE"] --> PlatformDetect["1. PLATFORM DETECTION
+(van-platform-detection.mdc)"]
+    PlatformDetect --> FileVerify["2. FILE VERIFICATION
+(van-file-verification.mdc)"]
+    FileVerify --> Complexity["3. EARLY COMPLEXITY
+DETERMINATION
+(van-complexity-determination.mdc)"]
+    Complexity --> Decision{"Level?"}
+    Decision -- "Level 1" --> L1Complete["Level 1 Init Complete"]
+    Decision -- "Level 2-4" --> ExitToPlan["Exit to PLAN Mode"]
+
+    %% Link to QA (Loaded separately)
+    QA_Entry["VAN QA MODE
+(Loaded Separately via
+'VAN QA' command)"] -.-> QA_Map["(van-qa-validation.mdc)"]
+
+    style PlatformDetect fill:#ccf,stroke:#333
+    style FileVerify fill:#ccf,stroke:#333
+    style Complexity fill:#ccf,stroke:#333
+    style QA_Map fill:#fcc,stroke:#333
+```
+
+**Next Step:** Load and process `van-platform-detection.mdc`. 

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-platform-detection.mdc

@@ -0,0 +1,50 @@
+---
+description: Visual process map for VAN mode platform detection
+globs: van-platform-detection.mdc
+alwaysApply: false
+---
+# VAN MODE: PLATFORM DETECTION
+
+> **TL;DR:** Detects the OS, determines path separators, and notes command adaptations required.
+
+## 🌐 PLATFORM DETECTION PROCESS
+
+```mermaid
+graph TD
+    PD["Platform Detection"] --> CheckOS["Detect Operating System"]
+    CheckOS --> Win["Windows"]
+    CheckOS --> Mac["macOS"]
+    CheckOS --> Lin["Linux"]
+    
+    Win & Mac & Lin --> Adapt["Adapt Commands<br>for Platform"]
+    
+    Win --> WinPath["Path: Backslash (\\)"]
+    Mac --> MacPath["Path: Forward Slash (/)"]
+    Lin --> LinPath["Path: Forward Slash (/)"]
+    
+    Win --> WinCmd["Command Adaptations:<br>dir, icacls, etc."]
+    Mac --> MacCmd["Command Adaptations:<br>ls, chmod, etc."]
+    Lin --> LinCmd["Command Adaptations:<br>ls, chmod, etc."]
+    
+    WinPath & MacPath & LinPath --> PathCP["Path Separator<br>Checkpoint"]
+    WinCmd & MacCmd & LinCmd --> CmdCP["Command<br>Checkpoint"]
+    
+    PathCP & CmdCP --> PlatformComplete["Platform Detection<br>Complete"]
+    
+    style PD fill:#4da6ff,stroke:#0066cc,color:white
+    style PlatformComplete fill:#10b981,stroke:#059669,color:white
+```
+
+## 📋 CHECKPOINT VERIFICATION TEMPLATE (Example)
+
+```
+✓ SECTION CHECKPOINT: PLATFORM DETECTION
+- Operating System Detected? [YES/NO]
+- Path Separator Confirmed? [YES/NO]
+- Command Adaptations Noted? [YES/NO]
+
+→ If all YES: Platform Detection Complete.
+→ If any NO: Resolve before proceeding.
+```
+
+**Next Step:** Load and process `van-file-verification.mdc`. 

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/build-test.mdc

@@ -0,0 +1,117 @@
+---
+description: Process map for VAN QA minimal build test
+globs: van-qa-checks/build-test.mdc
+alwaysApply: false
+---
+# VAN QA: MINIMAL BUILD TEST
+
+> **TL;DR:** This component performs a minimal build test to ensure core build functionality works properly.
+
+## 4️⃣ MINIMAL BUILD TEST PROCESS
+
+```mermaid
+graph TD
+    Start["Minimal Build Test"] --> CreateTest["Create Minimal<br>Test Project"]
+    CreateTest --> BuildTest["Attempt<br>Build"]
+    BuildTest --> BuildStatus{"Build<br>Successful?"}
+    
+    BuildStatus -->|"Yes"| RunTest["Run Basic<br>Functionality Test"]
+    BuildStatus -->|"No"| FixBuild["Fix Build<br>Issues"]
+    FixBuild --> RetryBuild["Retry Build"]
+    RetryBuild --> BuildStatus
+    
+    RunTest --> TestStatus{"Test<br>Passed?"}
+    TestStatus -->|"Yes"| TestSuccess["Minimal Build Test<br>✅ PASS"]
+    TestStatus -->|"No"| FixTest["Fix Test<br>Issues"]
+    FixTest --> RetryTest["Retry Test"]
+    RetryTest --> TestStatus
+    
+    style Start fill:#4da6ff,stroke:#0066cc,color:white
+    style TestSuccess fill:#10b981,stroke:#059669,color:white
+    style BuildStatus fill:#f6546a,stroke:#c30052,color:white
+    style TestStatus fill:#f6546a,stroke:#c30052,color:white
+```
+
+### Minimal Build Test Implementation:
+```powershell
+# Example: Perform minimal build test for a React project
+function Perform-MinimalBuildTest {
+    $buildSuccess = $false
+    $testSuccess = $false
+    
+    # Create minimal test project
+    $testDir = ".__build_test"
+    if (Test-Path $testDir) {
+        Remove-Item -Path $testDir -Recurse -Force
+    }
+    
+    try {
+        # Create minimal test directory
+        New-Item -Path $testDir -ItemType Directory | Out-Null
+        Push-Location $testDir
+        
+        # Initialize minimal package.json
+        @"
+{
+  "name": "build-test",
+  "version": "1.0.0",
+  "description": "Minimal build test",
+  "main": "index.js",
+  "scripts": {
+    "build": "echo Build test successful"
+  }
+}
+"@ | Set-Content -Path "package.json"
+        
+        # Attempt build
+        npm run build | Out-Null
+        $buildSuccess = $true
+        
+        # Create minimal test file
+        @"
+console.log('Test successful');
+"@ | Set-Content -Path "index.js"
+        
+        # Run basic test
+        node index.js | Out-Null
+        $testSuccess = $true
+        
+    } catch {
+        Write-Output "❌ Build test failed: $($_.Exception.Message)"
+    } finally {
+        Pop-Location
+        if (Test-Path $testDir) {
+            Remove-Item -Path $testDir -Recurse -Force
+        }
+    }
+    
+    # Display results
+    if ($buildSuccess -and $testSuccess) {
+        Write-Output "✅ Minimal build test passed successfully"
+        return $true
+    } else {
+        if (-not $buildSuccess) {
+            Write-Output "❌ Build process failed"
+        }
+        if (-not $testSuccess) {
+            Write-Output "❌ Basic functionality test failed"
+        }
+        return $false
+    }
+}
+```
+
+## 📋 MINIMAL BUILD TEST CHECKPOINT
+
+```
+✓ CHECKPOINT: MINIMAL BUILD TEST
+- Test project creation successful? [YES/NO]
+- Build process completed successfully? [YES/NO]
+- Basic functionality test passed? [YES/NO]
+
+→ If all YES: QA Validation complete, proceed to generate success report.
+→ If any NO: Fix build issues before continuing.
+```
+
+**Next Step (on PASS):** Load `van-qa-utils/reports.mdc` to generate success report.
+**Next Step (on FAIL):** Check `van-qa-utils/common-fixes.mdc` for build test fixes. 

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/config-check.mdc

@@ -0,0 +1,103 @@
+---
+description: Process map for VAN QA configuration validation
+globs: van-qa-checks/config-check.mdc
+alwaysApply: false
+---
+# VAN QA: CONFIGURATION VALIDATION
+
+> **TL;DR:** This component validates configuration files for proper syntax and compatibility with the project and platform.
+
+## 2️⃣ CONFIGURATION VALIDATION PROCESS
+
+```mermaid
+graph TD
+    Start["Configuration Validation"] --> IdentifyConfigs["Identify Configuration<br>Files"]
+    IdentifyConfigs --> ReadConfigs["Read Configuration<br>Files"]
+    ReadConfigs --> ValidateSyntax["Validate Syntax<br>and Format"]
+    ValidateSyntax --> SyntaxStatus{"Syntax<br>Valid?"}
+    
+    SyntaxStatus -->|"Yes"| CheckCompatibility["Check Compatibility<br>with Platform"]
+    SyntaxStatus -->|"No"| FixSyntax["Fix Syntax<br>Errors"]
+    FixSyntax --> RetryValidate["Retry Validation"]
+    RetryValidate --> SyntaxStatus
+    
+    CheckCompatibility --> CompatStatus{"Compatible with<br>Platform?"}
+    CompatStatus -->|"Yes"| ConfigSuccess["Configurations Validated<br>✅ PASS"]
+    CompatStatus -->|"No"| AdaptConfigs["Adapt Configurations<br>for Platform"]
+    AdaptConfigs --> RetryCompat["Retry Compatibility<br>Check"]
+    RetryCompat --> CompatStatus
+    
+    style Start fill:#4da6ff,stroke:#0066cc,color:white
+    style ConfigSuccess fill:#10b981,stroke:#059669,color:white
+    style SyntaxStatus fill:#f6546a,stroke:#c30052,color:white
+    style CompatStatus fill:#f6546a,stroke:#c30052,color:white
+```
+
+### Configuration Validation Implementation:
+```powershell
+# Example: Validate configuration files for a web project
+function Validate-Configurations {
+    $configFiles = @(
+        "package.json",
+        "tsconfig.json",
+        "vite.config.js"
+    )
+    
+    $invalidConfigs = @()
+    $incompatibleConfigs = @()
+    
+    foreach ($configFile in $configFiles) {
+        if (Test-Path $configFile) {
+            # Check JSON syntax for JSON files
+            if ($configFile -match "\.json$") {
+                try {
+                    Get-Content $configFile -Raw | ConvertFrom-Json | Out-Null
+                } catch {
+                    $invalidConfigs += "$configFile (JSON syntax error: $($_.Exception.Message))"
+                    continue
+                }
+            }
+            
+            # Specific configuration compatibility checks
+            if ($configFile -eq "vite.config.js") {
+                $content = Get-Content $configFile -Raw
+                # Check for React plugin in Vite config
+                if ($content -notmatch "react\(\)") {
+                    $incompatibleConfigs += "$configFile (Missing React plugin for React project)"
+                }
+            }
+        } else {
+            $invalidConfigs += "$configFile (file not found)"
+        }
+    }
+    
+    # Display results
+    if ($invalidConfigs.Count -eq 0 -and $incompatibleConfigs.Count -eq 0) {
+        Write-Output "✅ All configurations validated and compatible"
+        return $true
+    } else {
+        if ($invalidConfigs.Count -gt 0) {
+            Write-Output "❌ Invalid configurations: $($invalidConfigs -join ', ')"
+        }
+        if ($incompatibleConfigs.Count -gt 0) {
+            Write-Output "❌ Incompatible configurations: $($incompatibleConfigs -join ', ')"
+        }
+        return $false
+    }
+}
+```
+
+## 📋 CONFIGURATION VALIDATION CHECKPOINT
+
+```
+✓ CHECKPOINT: CONFIGURATION VALIDATION
+- All configuration files found? [YES/NO]
+- All configuration syntax valid? [YES/NO]
+- All configurations compatible with platform? [YES/NO]
+
+→ If all YES: Continue to Environment Validation.
+→ If any NO: Fix configuration issues before continuing.
+```
+
+**Next Step (on PASS):** Load `van-qa-checks/environment-check.mdc`.
+**Next Step (on FAIL):** Check `van-qa-utils/common-fixes.mdc` for configuration fixes. 

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/dependency-check.mdc

@@ -0,0 +1,147 @@
+---
+description: Process map for VAN QA dependency verification
+globs: van-qa-checks/dependency-check.mdc
+alwaysApply: false
+---
+# VAN QA: DEPENDENCY VERIFICATION
+
+> **TL;DR:** This component verifies that all required dependencies are installed and compatible with the project requirements.
+
+## 1️⃣ DEPENDENCY VERIFICATION PROCESS
+
+```mermaid
+graph TD
+    Start["Dependency Verification"] --> ReadDeps["Read Required Dependencies<br>from Creative Phase"]
+    ReadDeps --> CheckInstalled["Check if Dependencies<br>are Installed"]
+    CheckInstalled --> DepStatus{"All Dependencies<br>Installed?"}
+    
+    DepStatus -->|"Yes"| VerifyVersions["Verify Versions<br>and Compatibility"]
+    DepStatus -->|"No"| InstallMissing["Install Missing<br>Dependencies"]
+    InstallMissing --> VerifyVersions
+    
+    VerifyVersions --> VersionStatus{"Versions<br>Compatible?"}
+    VersionStatus -->|"Yes"| DepSuccess["Dependencies Verified<br>✅ PASS"]
+    VersionStatus -->|"No"| UpgradeVersions["Upgrade/Downgrade<br>as Needed"]
+    UpgradeVersions --> RetryVerify["Retry Verification"]
+    RetryVerify --> VersionStatus
+    
+    style Start fill:#4da6ff,stroke:#0066cc,color:white
+    style DepSuccess fill:#10b981,stroke:#059669,color:white
+    style DepStatus fill:#f6546a,stroke:#c30052,color:white
+    style VersionStatus fill:#f6546a,stroke:#c30052,color:white
+```
+
+### Windows (PowerShell) Implementation:
+```powershell
+# Example: Verify Node.js dependencies for a React project
+function Verify-Dependencies {
+    $requiredDeps = @{ "node" = ">=14.0.0"; "npm" = ">=6.0.0" }
+    $missingDeps = @(); $incompatibleDeps = @()
+    
+    # Check Node.js version
+    try { 
+        $nodeVersion = node -v
+        if ($nodeVersion -match "v(\d+)\.(\d+)\.(\d+)") {
+            $major = [int]$Matches[1]
+            if ($major -lt 14) {
+                $incompatibleDeps += "node (found $nodeVersion, required >=14.0.0)"
+            }
+        }
+    } catch {
+        $missingDeps += "node"
+    }
+    
+    # Check npm version
+    try { 
+        $npmVersion = npm -v
+        if ($npmVersion -match "(\d+)\.(\d+)\.(\d+)") {
+            $major = [int]$Matches[1]
+            if ($major -lt 6) {
+                $incompatibleDeps += "npm (found $npmVersion, required >=6.0.0)"
+            }
+        }
+    } catch {
+        $missingDeps += "npm"
+    }
+    
+    # Display results
+    if ($missingDeps.Count -eq 0 -and $incompatibleDeps.Count -eq 0) {
+        Write-Output "✅ All dependencies verified and compatible"
+        return $true
+    } else {
+        if ($missingDeps.Count -gt 0) {
+            Write-Output "❌ Missing dependencies: $($missingDeps -join ', ')"
+        }
+        if ($incompatibleDeps.Count -gt 0) {
+            Write-Output "❌ Incompatible versions: $($incompatibleDeps -join ', ')"
+        }
+        return $false
+    }
+}
+```
+
+### Mac/Linux (Bash) Implementation:
+```bash
+#!/bin/bash
+
+# Example: Verify Node.js dependencies for a React project
+verify_dependencies() {
+    local missing_deps=()
+    local incompatible_deps=()
+    
+    # Check Node.js version
+    if command -v node &> /dev/null; then
+        local node_version=$(node -v)
+        if [[ $node_version =~ v([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
+            local major=${BASH_REMATCH[1]}
+            if (( major < 14 )); then
+                incompatible_deps+=("node (found $node_version, required >=14.0.0)")
+            fi
+        fi
+    else
+        missing_deps+=("node")
+    fi
+    
+    # Check npm version
+    if command -v npm &> /dev/null; then
+        local npm_version=$(npm -v)
+        if [[ $npm_version =~ ([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
+            local major=${BASH_REMATCH[1]}
+            if (( major < 6 )); then
+                incompatible_deps+=("npm (found $npm_version, required >=6.0.0)")
+            fi
+        fi
+    else
+        missing_deps+=("npm")
+    fi
+    
+    # Display results
+    if [ ${#missing_deps[@]} -eq 0 ] && [ ${#incompatible_deps[@]} -eq 0 ]; then
+        echo "✅ All dependencies verified and compatible"
+        return 0
+    else
+        if [ ${#missing_deps[@]} -gt 0 ]; then
+            echo "❌ Missing dependencies: ${missing_deps[*]}"
+        fi
+        if [ ${#incompatible_deps[@]} -gt 0 ]; then
+            echo "❌ Incompatible versions: ${incompatible_deps[*]}"
+        fi
+        return 1
+    fi
+}
+```
+
+## 📋 DEPENDENCY VERIFICATION CHECKPOINT
+
+```
+✓ CHECKPOINT: DEPENDENCY VERIFICATION
+- Required dependencies identified? [YES/NO]
+- All dependencies installed? [YES/NO]
+- All versions compatible? [YES/NO]
+
+→ If all YES: Continue to Configuration Validation.
+→ If any NO: Fix dependency issues before continuing.
+```
+
+**Next Step (on PASS):** Load `van-qa-checks/config-check.mdc`.
+**Next Step (on FAIL):** Check `van-qa-utils/common-fixes.mdc` for dependency fixes. 

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/environment-check.mdc

@@ -0,0 +1,104 @@
+---
+description: Process map for VAN QA environment validation
+globs: van-qa-checks/environment-check.mdc
+alwaysApply: false
+---
+# VAN QA: ENVIRONMENT VALIDATION
+
+> **TL;DR:** This component verifies that the build environment is properly set up with required tools and permissions.
+
+## 3️⃣ ENVIRONMENT VALIDATION PROCESS
+
+```mermaid
+graph TD
+    Start["Environment Validation"] --> CheckEnv["Check Build Environment"]
+    CheckEnv --> VerifyBuildTools["Verify Build Tools"]
+    VerifyBuildTools --> ToolsStatus{"Build Tools<br>Available?"}
+    
+    ToolsStatus -->|"Yes"| CheckPerms["Check Permissions<br>and Access"]
+    ToolsStatus -->|"No"| InstallTools["Install Required<br>Build Tools"]
+    InstallTools --> RetryTools["Retry Verification"]
+    RetryTools --> ToolsStatus
+    
+    CheckPerms --> PermsStatus{"Permissions<br>Sufficient?"}
+    PermsStatus -->|"Yes"| EnvSuccess["Environment Validated<br>✅ PASS"]
+    PermsStatus -->|"No"| FixPerms["Fix Permission<br>Issues"]
+    FixPerms --> RetryPerms["Retry Permission<br>Check"]
+    RetryPerms --> PermsStatus
+    
+    style Start fill:#4da6ff,stroke:#0066cc,color:white
+    style EnvSuccess fill:#10b981,stroke:#059669,color:white
+    style ToolsStatus fill:#f6546a,stroke:#c30052,color:white
+    style PermsStatus fill:#f6546a,stroke:#c30052,color:white
+```
+
+### Environment Validation Implementation:
+```powershell
+# Example: Validate environment for a web project
+function Validate-Environment {
+    $requiredTools = @(
+        @{Name = "git"; Command = "git --version"},
+        @{Name = "node"; Command = "node --version"},
+        @{Name = "npm"; Command = "npm --version"}
+    )
+    
+    $missingTools = @()
+    $permissionIssues = @()
+    
+    # Check build tools
+    foreach ($tool in $requiredTools) {
+        try {
+            Invoke-Expression $tool.Command | Out-Null
+        } catch {
+            $missingTools += $tool.Name
+        }
+    }
+    
+    # Check write permissions in project directory
+    try {
+        $testFile = ".__permission_test"
+        New-Item -Path $testFile -ItemType File -Force | Out-Null
+        Remove-Item -Path $testFile -Force
+    } catch {
+        $permissionIssues += "Current directory (write permission denied)"
+    }
+    
+    # Check if port 3000 is available (commonly used for dev servers)
+    try {
+        $listener = New-Object System.Net.Sockets.TcpListener([System.Net.IPAddress]::Loopback, 3000)
+        $listener.Start()
+        $listener.Stop()
+    } catch {
+        $permissionIssues += "Port 3000 (already in use or access denied)"
+    }
+    
+    # Display results
+    if ($missingTools.Count -eq 0 -and $permissionIssues.Count -eq 0) {
+        Write-Output "✅ Environment validated successfully"
+        return $true
+    } else {
+        if ($missingTools.Count -gt 0) {
+            Write-Output "❌ Missing tools: $($missingTools -join ', ')"
+        }
+        if ($permissionIssues.Count -gt 0) {
+            Write-Output "❌ Permission issues: $($permissionIssues -join ', ')"
+        }
+        return $false
+    }
+}
+```
+
+## 📋 ENVIRONMENT VALIDATION CHECKPOINT
+
+```
+✓ CHECKPOINT: ENVIRONMENT VALIDATION
+- All required build tools installed? [YES/NO]
+- Project directory permissions sufficient? [YES/NO]
+- Required ports available? [YES/NO]
+
+→ If all YES: Continue to Minimal Build Test.
+→ If any NO: Fix environment issues before continuing.
+```
+
+**Next Step (on PASS):** Load `van-qa-checks/build-test.mdc`.
+**Next Step (on FAIL):** Check `van-qa-utils/common-fixes.mdc` for environment fixes. 

data/.cursor/rules/isolation_rules/visual-maps/van_mode_split/van-qa-checks/file-verification.mdc

@@ -0,0 +1 @@
+