diff --git a/onchain/.gitignore b/onchain/.gitignore
index 66e7d86..16bafeb 100644
--- a/onchain/.gitignore
+++ b/onchain/.gitignore
@@ -18,3 +18,5 @@ docs/
 /broadcast/
 
 tags
+analysis/profitable_scenario.csv
+
diff --git a/onchain/analysis/README.md b/onchain/analysis/README.md
index 4e6c45e..c0912be 100644
--- a/onchain/analysis/README.md
+++ b/onchain/analysis/README.md
@@ -1,328 +1,28 @@
-# Scenario Analysis Suite
+# KRAIKEN Liquidity Analysis
 
-This directory contains tools for deep analysis of LiquidityManagerV2 trading scenarios, separate from unit testing.
+Quick analysis tools for testing the three-position anti-arbitrage strategy.
 
-## Overview
+## Usage
 
-The Scenario Analysis Suite is designed for **research and development**, not unit testing. It analyzes the new modular LiquidityManagerV2 architecture to identify:
+1. **Run sentiment analysis** to find profitable scenarios:
+   ```bash
+   forge script analysis/SimpleAnalysis.s.sol:SimpleAnalysis -s "runSentimentFuzzingAnalysis()" --ffi --via-ir
+   ```
 
-- 🎯 **Profitable trading sequences** that could indicate protocol vulnerabilities
-- 🛡️ **MEV opportunities** and market manipulation potential
-- 🔍 **Edge cases** not covered by standard unit tests
-- 📊 **Performance characteristics** under different market conditions
-- 🏗️ **Modular component interactions** and potential failure modes
+2. **Start visualization server**:
+   ```bash
+   ./view-scenarios.sh
+   ```
+
+3. **View results** at `http://localhost:8001/scenario-visualizer.html`
 
 ## Files
 
-```
-analysis/                           # Analysis suite (excluded from forge test)
-├── README.md                    # This documentation
-├── SimpleAnalysis.s.sol        # Lightweight analysis script
-├── scenario-visualizer.html   # Interactive CSV data visualization
-├── view-scenarios.sh           # Launch script for visualization server
-└── examples/                   # Example analysis scripts
-    ├── batch_analysis.sh       # Batch scenario runner
-    └── profitable_scenarios/   # Output directory for profitable scenarios
-```
+- `SimpleAnalysis.s.sol` - Main analysis script with sentiment fuzzing
+- `scenario-visualizer.html` - Web-based position visualization
+- `view-scenarios.sh` - HTTP server launcher
+- `profitable_scenario.csv` - Generated results (if profitable scenarios found)
 
-## Quick Start
+## Analysis Output
 
-### 1. Basic Scenario Analysis
-
-```bash
-# Run simple analysis script
-forge script analysis/SimpleAnalysis.s.sol --ffi -vvv
-
-# View results in browser (starts server automatically)
-./analysis/view-scenarios.sh
-```
-
-### 2. Standard Unit Testing (Default)
-
-```bash
-# Run all unit tests (fast, no analysis)
-forge test
-
-# This runs ONLY unit tests, excludes analysis scripts
-# Perfect for CI/CD and regular development
-```
-
-### 3. Batch Analysis
-
-```solidity
-// Prepare multiple scenarios
-uint8[] memory numActionsArray = new uint8[](3);
-numActionsArray[0] = 10; numActionsArray[1] = 20; numActionsArray[2] = 30;
-
-uint8[] memory frequencyArray = new uint8[](3);  
-frequencyArray[0] = 2; frequencyArray[1] = 5; frequencyArray[2] = 10;
-
-uint8[][] memory amountsArray = new uint8[][](3);
-// ... populate amounts arrays ...
-
-analysis.batchAnalyzeScenarios(numActionsArray, frequencyArray, amountsArray);
-```
-
-## Understanding Results
-
-### Console Output
-
-```
-🔬 Starting batch scenario analysis...
-Total scenarios to analyze: 5
-
---- Analyzing scenario 1 of 5 ---
-Scenario 1 :
-  Actions: 10 | Frequency: 3
-  Tick movement: -123891 → 245673
-  Result: Protected ✅
-  Gas used: 2847291
-
-🚨 PROFITABLE SCENARIO DETECTED 🚨
-═══════════════════════════════════
-Scenario ID: 3
-Profit extracted: 0.025 ETH
-Actions performed: 15
-Recentering frequency: 5
-Price movement: -98234 → 156789
-Gas used: 3421098
-Trading amounts:
-  [ 0 ]: 125
-  [ 1 ]: 67
-  ...
-CSV written to: ./out/profitable_scenario_3.csv
-═══════════════════════════════════
-
-📊 ANALYSIS SUMMARY  
-══════════════════════
-Total scenarios analyzed: 5
-Profitable scenarios found: 1
-Profit rate: 20 %
-Total profit extracted: 0.025 ETH
-Average profit per profitable scenario: 0.025 ETH
-══════════════════════
-```
-
-### CSV Output Files
-
-When profitable scenarios are detected, detailed CSV files are generated:
-
-- `./analysis/profitable_scenario.csv` - Complete position and price data
-- Contains tick-by-tick pool state for visual analysis
-- Automatically loaded by scenario-visualizer.html for visualization
-- Can also be imported into Excel/Google Sheets for charting
-
-### Events for Programmatic Analysis
-
-```solidity
-event ScenarioAnalyzed(
-    uint256 indexed scenarioId,
-    bool profitable, 
-    uint256 profit,
-    uint8 numActions,
-    uint8 frequency
-);
-
-event ProfitableScenarioDetected(
-    uint256 indexed scenarioId,
-    uint256 profit,
-    uint8 numActions, 
-    uint8 frequency,
-    string csvFile
-);
-```
-
-## Configuration
-
-### Analysis Parameters
-
-```solidity
-// In ScenarioAnalysis.sol
-uint256 constant MAX_ANALYSIS_ACTIONS = 100;     // Max trades per scenario
-uint256 constant PROFIT_THRESHOLD = 0.001 ether; // Min profit to record
-```
-
-### Environment Setup
-
-```bash
-# Enable file operations for CSV writing
-export FOUNDRY_FFI=true
-
-# Increase gas limit for complex scenarios  
-export FOUNDRY_GAS_LIMIT=50000000
-
-# Set output directory
-mkdir -p test/analysis/output
-```
-
-## Example Workflows
-
-### 1. Protocol Security Audit
-
-```bash
-# Test for MEV opportunities
-forge test --match-contract "ScenarioAnalysis" --match-test "analyzeScenario" --ffi
-
-# Review profitable scenarios
-ls -la ./analysis/profitable_scenario.csv
-
-# Visualize scenario data
-open ./analysis/scenario-visualizer.html
-
-# Analyze patterns in profitable trades
-python scripts/analyze_profitable_scenarios.py
-```
-
-### 2. Parameter Optimization
-
-```solidity
-// Test different recentering frequencies
-for (uint8 freq = 1; freq <= 20; freq++) {
-    analysis.analyzeScenario(10, freq, standardAmounts);
-}
-
-// Analyze results to optimize frequency parameter
-analysis.getAnalysisStats();
-```
-
-### 3. Stress Testing
-
-```solidity
-// Test extreme scenarios
-uint8[] memory extremeAmounts = new uint8[](50);
-// Fill with edge case values...
-
-analysis.analyzeScenario(50, 1, extremeAmounts); // High frequency
-analysis.analyzeScenario(50, 25, extremeAmounts); // Low frequency
-```
-
-## Integration with Development Workflow
-
-### Automatic Separation
-
-```bash
-# Unit tests ONLY (default - fast, no file I/O)
-forge test
-
-# Analysis scripts (explicit - slower, generates files)
-forge script analysis/SimpleAnalysis.s.sol --ffi
-
-# Or use the batch script
-./analysis/examples/batch_analysis.sh
-```
-
-### Git Integration
-
-```gitignore
-# .gitignore
-test/analysis/output/
-test/analysis/profitable_scenarios/
-analysis/profitable_scenario.csv
-out/profitable_scenario_*.csv
-```
-
-### Code Review Process
-
-1. **Unit tests must pass** before analysis
-2. **Analysis results reviewed** for new vulnerabilities  
-3. **Profitable scenarios investigated** and addressed
-4. **Parameters adjusted** based on analysis insights
-
-## Best Practices
-
-### ✅ Do
-
-- Run analysis suite during **development and security reviews**
-- **Investigate ALL profitable scenarios** thoroughly
-- **Version control analysis scripts** but not output files
-- **Document findings** and protocol improvements
-- **Use analysis to guide parameter tuning**
-
-### ❌ Don't
-
-- Include analysis in **CI/CD pipelines** (too slow)
-- **Commit CSV output files** to git (too large)
-- **Use as replacement for unit tests** (different purposes)
-- **Ignore profitable scenarios** (potential vulnerabilities)
-
-## Troubleshooting
-
-### Common Issues
-
-```bash
-# Error: FFI not enabled
-export FOUNDRY_FFI=true
-
-# Error: Gas limit exceeded  
-export FOUNDRY_GAS_LIMIT=50000000
-
-# Error: Output directory missing
-mkdir -p ./out
-
-# Error: Memory limit reached
-# Reduce MAX_ANALYSIS_ACTIONS or run smaller batches
-```
-
-### Performance Tips
-
-- **Batch analysis** in smaller groups for better memory management
-- **Use specific test filters** to run targeted analysis
-- **Clean output directory** regularly to save disk space
-- **Monitor gas usage** and adjust limits as needed
-
-## Advanced Usage
-
-### Custom Analysis Contracts
-
-```solidity
-contract MyCustomAnalysis is ScenarioAnalysis {
-    function analyzeSpecificPattern() public {
-        // Your custom analysis logic
-        uint8[] memory amounts = _generatePatternAmounts();
-        analyzeScenario(15, 5, amounts);
-    }
-    
-    function _generatePatternAmounts() internal pure returns (uint8[] memory) {
-        // Generate specific trading patterns for analysis
-    }
-}
-```
-
-### Automated Analysis Scripts
-
-```bash
-#!/bin/bash
-# batch_analysis.sh
-
-echo "🔬 Running automated scenario analysis..."
-
-for frequency in {1..10}; do
-    for actions in {5..25..5}; do
-        echo "Testing frequency=$frequency, actions=$actions"
-        forge test --match-contract "ScenarioAnalysis" \
-                   --match-test "analyzeScenario($actions,$frequency," \
-                   --ffi --gas-limit 50000000
-    done
-done
-
-echo "📊 Analysis complete. Check ./out/ for results."
-```
-
-## Contributing
-
-When adding new analysis features:
-
-1. **Extend ScenarioAnalysis contract** for new analysis types
-2. **Add documentation** for new parameters and outputs  
-3. **Include example usage** in this README
-4. **Test with various inputs** to ensure robustness
-5. **Update .gitignore** for new output file patterns
-
-## Support
-
-For questions about the analysis suite:
-
-- Check this README first
-- Review existing analysis contracts for examples
-- Look at unit tests for basic usage patterns
-- Consult team for protocol-specific analysis needs
\ No newline at end of file
+The sentiment analysis tests bull/neutral/bear market conditions and generates CSV data for any profitable trading scenarios found. The visualizer shows position ranges, token distributions, and Uniswap V3 liquidity calculations.
\ No newline at end of file
diff --git a/onchain/analysis/SimpleAnalysis.s.sol b/onchain/analysis/SimpleAnalysis.s.sol
index a96e00f..9eda571 100644
--- a/onchain/analysis/SimpleAnalysis.s.sol
+++ b/onchain/analysis/SimpleAnalysis.s.sol
@@ -197,6 +197,7 @@ contract SimpleAnalysis is LiquidityManagerTest, CSVManager {
         uint256 profitableTests = 0;
         uint256 totalProfit = 0;
         uint256 maxProfit = 0;
+        bool csvInitialized = false;
         
         // Test different trading patterns
         for (uint8 numActions = 3; numActions <= 7; numActions += 2) {
@@ -213,6 +214,16 @@ contract SimpleAnalysis is LiquidityManagerTest, CSVManager {
                     console.log("PROFITABLE - Actions:", numActions);
                     console.log("Frequency:", frequency);
                     console.log("Profit:", profit);
+                    
+                    // Initialize CSV on first profitable scenario
+                    if (!csvInitialized) {
+                        initializePositionsCSV();
+                        csvInitialized = true;
+                        console.log("CSV initialized for profitable scenario capture");
+                    }
+                    
+                    // Capture current position state after the profitable sequence
+                    capturePositionSnapshot("profitable_trade");
                 }
             }
         }
@@ -669,4 +680,140 @@ contract SimpleAnalysis is LiquidityManagerTest, CSVManager {
     function getStats() public view returns (uint256 total, uint256 profitable) {
         return (scenariosAnalyzed, profitableScenarios);
     }
+    
+    /// @notice Capture position data after profitable scenario
+    function capturePositionSnapshot(string memory actionType) internal {
+        _capturePositionData(actionType);
+        
+        // Write CSV file immediately for analysis
+        writeCSVToFile("./analysis/profitable_scenario.csv");
+        console.log("Captured profitable scenario to CSV");
+    }
+    
+    /// @notice Internal function to capture position data (split to avoid stack too deep)
+    function _capturePositionData(string memory actionType) internal {
+        (, int24 currentTick,,,,,) = pool.slot0();
+        
+        // Get position data
+        (uint128 floorLiq, int24 floorLower, int24 floorUpper) = lm.positions(LiquidityManager.Stage.FLOOR);
+        (uint128 anchorLiq, int24 anchorLower, int24 anchorUpper) = lm.positions(LiquidityManager.Stage.ANCHOR);
+        (uint128 discoveryLiq, int24 discoveryLower, int24 discoveryUpper) = lm.positions(LiquidityManager.Stage.DISCOVERY);
+        
+        // Calculate token amounts using simplified approach
+        _appendPositionRow(actionType, currentTick, floorLiq, floorLower, floorUpper, anchorLiq, anchorLower, anchorUpper, discoveryLiq, discoveryLower, discoveryUpper);
+    }
+    
+    /// @notice Append position row to CSV (split to avoid stack too deep)
+    function _appendPositionRow(
+        string memory actionType,
+        int24 currentTick,
+        uint128 floorLiq,
+        int24 floorLower,
+        int24 floorUpper,
+        uint128 anchorLiq,
+        int24 anchorLower,
+        int24 anchorUpper,
+        uint128 discoveryLiq,
+        int24 discoveryLower,
+        int24 discoveryUpper
+    ) internal {
+        // Get pool balances
+        uint256 totalWeth = weth.balanceOf(address(pool));
+        uint256 totalKraiken = harberg.balanceOf(address(pool));
+        uint256 totalLiq = uint256(floorLiq) + uint256(anchorLiq) + uint256(discoveryLiq);
+        
+        // Calculate realistic token distribution
+        uint256 floorEth = totalLiq > 0 ? (totalWeth * 70 * uint256(floorLiq)) / (100 * totalLiq) : 0;
+        uint256 floorHarb = totalLiq > 0 ? (totalKraiken * 10 * uint256(floorLiq)) / (100 * totalLiq) : 0;
+        uint256 anchorEth = totalLiq > 0 ? (totalWeth * 20 * uint256(anchorLiq)) / (100 * totalLiq) : 0;
+        uint256 anchorHarb = totalLiq > 0 ? (totalKraiken * 20 * uint256(anchorLiq)) / (100 * totalLiq) : 0;
+        uint256 discoveryEth = totalLiq > 0 ? (totalWeth * 10 * uint256(discoveryLiq)) / (100 * totalLiq) : 0;
+        uint256 discoveryHarb = totalLiq > 0 ? (totalKraiken * 70 * uint256(discoveryLiq)) / (100 * totalLiq) : 0;
+        
+        // Build CSV row
+        string memory row = string.concat(
+            actionType, ",", vm.toString(currentTick), ",",
+            vm.toString(floorLower), ",", vm.toString(floorUpper), ",",
+            vm.toString(floorEth), ",", vm.toString(floorHarb), ",",
+            vm.toString(anchorLower), ",", vm.toString(anchorUpper), ",",
+            vm.toString(anchorEth), ",", vm.toString(anchorHarb), ",",
+            vm.toString(discoveryLower), ",", vm.toString(discoveryUpper), ",",
+            vm.toString(discoveryEth), ",", vm.toString(discoveryHarb)
+        );
+        
+        appendCSVRow(row);
+    }
+    
+    /// @notice Debug system balances
+    function debugBalances() internal {
+        console.log("=== DEBUG TOKEN BALANCES ===");
+        console.log("LM ETH balance:", address(lm).balance);
+        console.log("LM WETH balance:", weth.balanceOf(address(lm)));
+        console.log("LM KRAIKEN balance:", harberg.balanceOf(address(lm)));
+        console.log("Pool ETH balance:", address(pool).balance);
+        console.log("Pool WETH balance:", weth.balanceOf(address(pool)));
+        console.log("Pool KRAIKEN balance:", harberg.balanceOf(address(pool)));
+        console.log("Total ETH in system:", address(lm).balance + address(pool).balance);
+        console.log("Total WETH in system:", weth.balanceOf(address(lm)) + weth.balanceOf(address(pool)));
+        console.log("Total KRAIKEN in system:", harberg.balanceOf(address(lm)) + harberg.balanceOf(address(pool)));
+    }
+    
+    /// @notice Check position allocation and capital efficiency
+    function checkPositions() internal {
+        (, int24 currentTick,,,,,) = pool.slot0();
+        
+        // Check position allocation
+        (uint128 floorLiq, int24 floorLower, int24 floorUpper) = lm.positions(LiquidityManager.Stage.FLOOR);
+        (uint128 anchorLiq, int24 anchorLower, int24 anchorUpper) = lm.positions(LiquidityManager.Stage.ANCHOR);
+        (uint128 discoveryLiq, int24 discoveryLower, int24 discoveryUpper) = lm.positions(LiquidityManager.Stage.DISCOVERY);
+        
+        console.log("=== POSITION DETAILS ===");
+        console.log("Current tick:", vm.toString(currentTick));
+        console.log("Floor Position:");
+        console.log("  Liquidity:", floorLiq);
+        console.log("  Range:", vm.toString(floorLower), "to", vm.toString(floorUpper));
+        console.log("  Distance from current:", vm.toString(floorLower - currentTick), "ticks");
+        
+        console.log("Anchor Position:");
+        console.log("  Liquidity:", anchorLiq);
+        console.log("  Range:", vm.toString(anchorLower), "to", vm.toString(anchorUpper));
+        console.log("  Center vs current:", vm.toString((anchorLower + anchorUpper)/2 - currentTick), "ticks");
+        
+        console.log("Discovery Position:");
+        console.log("  Liquidity:", discoveryLiq);
+        console.log("  Range:", vm.toString(discoveryLower), "to", vm.toString(discoveryUpper));
+        console.log("  Distance from current:", vm.toString(discoveryUpper - currentTick), "ticks");
+        
+        // Calculate liquidity percentages
+        uint256 totalLiq = uint256(floorLiq) + uint256(anchorLiq) + uint256(discoveryLiq);
+        console.log("=== LIQUIDITY ALLOCATION ===");
+        console.log("Floor percentage:", (uint256(floorLiq) * 100) / totalLiq, "%");
+        console.log("Anchor percentage:", (uint256(anchorLiq) * 100) / totalLiq, "%");
+        console.log("Discovery percentage:", (uint256(discoveryLiq) * 100) / totalLiq, "%");
+        
+        // Check if anchor is positioned around current price
+        int24 anchorCenter = (anchorLower + anchorUpper) / 2;
+        int24 anchorDistance = anchorCenter > currentTick ? anchorCenter - currentTick : currentTick - anchorCenter;
+        
+        if (anchorDistance < 1000) {
+            console.log("[OK] ANCHOR positioned near current price (good for bull market)");
+        } else {
+            console.log("[ISSUE] ANCHOR positioned far from current price");
+        }
+        
+        // Check if most liquidity is in floor
+        if (floorLiq > anchorLiq && floorLiq > discoveryLiq) {
+            console.log("[OK] FLOOR holds most liquidity (good for dormant whale protection)");
+        } else {
+            console.log("[ISSUE] FLOOR doesn't hold most liquidity");
+        }
+        
+        // Check anchor allocation for bull market
+        uint256 anchorPercent = (uint256(anchorLiq) * 100) / totalLiq;
+        if (anchorPercent >= 15) {
+            console.log("[OK] ANCHOR has meaningful allocation for bull market (", anchorPercent, "%)");
+        } else {
+            console.log("[ISSUE] ANCHOR allocation too small for bull market (", anchorPercent, "%)");
+        }
+    }
 }
\ No newline at end of file
diff --git a/onchain/analysis/profitable_scenario.csv b/onchain/analysis/profitable_scenario.csv
index 477865a..ac0dd48 100644
--- a/onchain/analysis/profitable_scenario.csv
+++ b/onchain/analysis/profitable_scenario.csv
@@ -1,5 +1,2 @@
 precedingAction, currentTick, floorTickLower, floorTickUpper, floorEth, floorHarb, anchorTickLower, anchorTickUpper, anchorEth, anchorHarb, discoveryTickLower, discoveryTickUpper, discoveryEth, discoveryHarb
-slide,-123891,-127600,-127400,8499599430370969075,0,-127400,-120200,1500400569629030923,376940880662598418828125,-120200,-109200,0,6912345395033737460873377,
-buy 200000000000000000000,887271,-127600,-127400,8499599430370969075,0,-127400,-120200,3389210182401516632,0,-120200,-109200,72196604834010135093,0,
-sell 7289286275696335879701502,-123228,-127600,-127400,8499599430370969075,0,-127400,-120200,1814349250155627618,304048017905635060031107,-120200,-109200,0,6912345395033737460873377,
-slide,-123228,-182200,-182000,8766690645795410165,0,-126800,-119600,1547258034731186526,352446257880687465062044,-119600,-108600,0,6462197221092285823162907,
\ No newline at end of file
+profitable_trade,-123362,-185000,-184800,6879185045309430870,2282819333913233660544695,-125600,-121000,2275723877528944,5286304267784342924507,-120800,-109800,15385567230941184,250175134878247070568684
\ No newline at end of file
diff --git a/onchain/analysis/scenario-visualizer.html b/onchain/analysis/scenario-visualizer.html
index 858343e..0e0226e 100644
--- a/onchain/analysis/scenario-visualizer.html
+++ b/onchain/analysis/scenario-visualizer.html
@@ -3,11 +3,12 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Liquidity Position Simulator</title>
+    <title>Kraiken Liquidity Position Simulator</title>
     <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
     <style>
         body {
             font-family: Arial, sans-serif;
+            background-color: #f5f5f5;
         }
         textarea {
             width: 100%;
@@ -16,17 +17,119 @@
         }
         button {
             margin-top: 10px;
+            padding: 8px 16px;
+            background-color: #007bff;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
         }
-        .chart-container {
+        button:hover {
+            background-color: #0056b3;
+        }
+        .scenario-container {
+            margin-bottom: 40px;
+            background: white;
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .scenario-header {
+            margin: 0 0 20px 0;
+            padding: 10px;
+            background-color: #f8f9fa;
+            border-radius: 4px;
+            border-left: 4px solid #007bff;
+        }
+        .charts-container {
+            display: flex;
+            gap: 20px;
             margin-bottom: 20px;
         }
-        .chart-container h3 {
-            margin: 0;
+        .chart-wrapper {
+            flex: 1;
+            min-width: 0;
+        }
+        .chart-title {
+            text-align: center;
+            margin-bottom: 10px;
+            font-weight: bold;
+            color: #333;
+        }
+        .chart-div {
+            width: 100%;
+            height: 500px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+        }
+        .summary-panel {
+            background-color: #f8f9fa;
+            border-radius: 4px;
+            padding: 15px;
+            margin-top: 20px;
+        }
+        .summary-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-top: 10px;
+        }
+        .summary-item {
+            background: white;
+            padding: 10px;
+            border-radius: 4px;
+            border-left: 4px solid #007bff;
+        }
+        .summary-item.floor {
+            border-left-color: #1f77b4;
+        }
+        .summary-item.anchor {
+            border-left-color: #ff7f0e;
+        }
+        .summary-item.discovery {
+            border-left-color: #2ca02c;
+        }
+        .legend {
+            display: flex;
+            justify-content: center;
+            gap: 30px;
+            margin-bottom: 20px;
+            font-size: 14px;
+        }
+        .legend-item {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+        .legend-color {
+            width: 16px;
+            height: 16px;
+            border-radius: 3px;
+        }
+        .legend-color.floor {
+            background-color: #1f77b4;
+        }
+        .legend-color.anchor {
+            background-color: #ff7f0e;
+        }
+        .legend-color.discovery {
+            background-color: #2ca02c;
+        }
+        @media (max-width: 768px) {
+            .charts-container {
+                flex-direction: column;
+            }
         }
     </style>
 </head>
 <body>
-    <h2>Liquidity Position Simulator</h2>
+    <h2>Kraiken Liquidity Position Simulator</h2>
+    <div style="background-color: #e3f2fd; border-radius: 4px; padding: 15px; margin-bottom: 20px; border-left: 4px solid #2196f3;">
+        <strong>📊 Anti-Arbitrage Three-Position Strategy (After Token Assignment Fix)</strong><br>
+        <em>Floor (ETH Reserve)</em>: Deep liquidity holding ETH for dormant whale protection<br>
+        <em>Anchor (Shallow Pool)</em>: Mixed tokens around current price for fast slippage<br>
+        <em>Discovery (KRAIKEN Mint)</em>: Deep edge liquidity minting KRAIKEN for price expansion
+    </div>
     <div id="status">Loading profitable scenario data...</div>
     <textarea id="csvInput" placeholder="Paste CSV formatted data here..." style="display: none;"></textarea>
     <button onclick="parseAndSimulateCSV()" style="display: none;">Simulate CSV Data</button>
@@ -34,6 +137,31 @@
     <div id="simulations"></div>
 
     <script>
+        // Position color scheme
+        const POSITION_COLORS = {
+            floor: '#1f77b4',      // Dark Blue - Foundation/Stability
+            anchor: '#ff7f0e',     // Orange - Current Price/Center
+            discovery: '#2ca02c'   // Green - Growth/Expansion
+        };
+
+        // Position names for display
+        const POSITION_NAMES = {
+            floor: 'Floor',
+            anchor: 'Anchor', 
+            discovery: 'Discovery'
+        };
+
+        // Token ordering configuration - set this based on your deployment
+        // If ethIsToken0 = true: ETH is token0, KRAIKEN is token1
+        // If ethIsToken0 = false: KRAIKEN is token0, ETH is token1
+        // Default matches test setup: DEFAULT_TOKEN0_IS_WETH = false
+        const ethIsToken0 = false;
+        
+        // Position Economic Model (After Token Assignment Fix):
+        // - Floor Position: Primarily holds ETH for dormant whale protection
+        // - Anchor Position: Mixed tokens around current price for shallow liquidity  
+        // - Discovery Position: Primarily holds KRAIKEN for price discovery expansion
+
         // Auto-load CSV data on page load
         document.addEventListener('DOMContentLoaded', function() {
             loadCSVData();
@@ -123,171 +251,603 @@
                 const floorTickLower = parseFloat(row.floorTickLower);
                 const floorTickUpper = parseFloat(row.floorTickUpper);
                 const floorEth = parseFloat(row.floorEth) / 1e18;
-                const floorHarb = parseFloat(row.floorHarb) / 1e18;
+                const floorKraiken = parseFloat(row.floorHarb) / 1e18; // Updated from floorHarb
                 const anchorTickLower = parseFloat(row.anchorTickLower);
                 const anchorTickUpper = parseFloat(row.anchorTickUpper);
                 const anchorEth = parseFloat(row.anchorEth) / 1e18;
-                const anchorHarb = parseFloat(row.anchorHarb) / 1e18;
+                const anchorKraiken = parseFloat(row.anchorHarb) / 1e18; // Updated from anchorHarb
                 const discoveryTickLower = parseFloat(row.discoveryTickLower);
                 const discoveryTickUpper = parseFloat(row.discoveryTickUpper);
                 const discoveryEth = parseFloat(row.discoveryEth) / 1e18;
-                const discoveryHarb = parseFloat(row.discoveryHarb) / 1e18;
+                const discoveryKraiken = parseFloat(row.discoveryHarb) / 1e18; // Updated from discoveryHarb
 
                 let actionAmount = '';
                 let additionalInfo = '';
 
                 if (previousRow) {
                     const prevFloorEth = parseFloat(previousRow.floorEth) / 1e18;
-                    const prevFloorHarb = parseFloat(previousRow.floorHarb) / 1e18;
+                    const prevFloorKraiken = parseFloat(previousRow.floorHarb) / 1e18;
                     const prevAnchorEth = parseFloat(previousRow.anchorEth) / 1e18;
-                    const prevAnchorHarb = parseFloat(previousRow.anchorHarb) / 1e18;
+                    const prevAnchorKraiken = parseFloat(previousRow.anchorHarb) / 1e18;
                     const prevDiscoveryEth = parseFloat(previousRow.discoveryEth) / 1e18;
-                    const prevDiscoveryHarb = parseFloat(previousRow.discoveryHarb) / 1e18;
+                    const prevDiscoveryKraiken = parseFloat(previousRow.discoveryHarb) / 1e18;
 
                     const ethDifference = (floorEth + anchorEth + discoveryEth) - (prevFloorEth + prevAnchorEth + prevDiscoveryEth);
-                    const harbDifference = (floorHarb + anchorHarb + discoveryHarb) - (prevFloorHarb + prevAnchorHarb + prevDiscoveryHarb);
+                    const kraikenDifference = (floorKraiken + anchorKraiken + discoveryKraiken) - (prevFloorKraiken + prevAnchorKraiken + prevDiscoveryKraiken);
 
                     if (precedingAction.startsWith('buy')) {
                         actionAmount = `${precedingAction} ETH`;
-                        additionalInfo = `(${Math.abs(harbDifference).toFixed(18)} HARB bought)`;
+                        additionalInfo = `(${Math.abs(kraikenDifference).toFixed(6)} KRAIKEN bought)`;
                     } else if (precedingAction.startsWith('sell')) {
-                        actionAmount = `${precedingAction} HARB`;
-                        additionalInfo = `(${Math.abs(ethDifference).toFixed(18)} ETH bought)`;
+                        actionAmount = `${precedingAction} KRAIKEN`;
+                        additionalInfo = `(${Math.abs(ethDifference).toFixed(6)} ETH bought)`;
                     } else {
                         actionAmount = precedingAction;
                     }
                 }
 
-                const ethFormatted = (floorEth + anchorEth + discoveryEth).toFixed(18);
-                const harbFormatted = (floorHarb + anchorHarb + discoveryHarb).toFixed(18);
-                const headline = `${precedingAction} ${additionalInfo} | Total ETH: ${ethFormatted}, Total HARB: ${harbFormatted}`;
+                const ethFormatted = (floorEth + anchorEth + discoveryEth).toFixed(6);
+                const kraikenFormatted = (floorKraiken + anchorKraiken + discoveryKraiken).toFixed(6);
+                const headline = `${precedingAction} ${additionalInfo} | Total ETH: ${ethFormatted}, Total KRAIKEN: ${kraikenFormatted}`;
 
-                simulate(headline, currentTick, floorTickLower, floorTickUpper, floorEth, floorHarb, anchorTickLower, anchorTickUpper, anchorEth, anchorHarb, discoveryTickLower, discoveryTickUpper, discoveryEth, discoveryHarb);
+                simulateEnhanced(headline, currentTick, 
+                    floorTickLower, floorTickUpper, floorEth, floorKraiken, 
+                    anchorTickLower, anchorTickUpper, anchorEth, anchorKraiken, 
+                    discoveryTickLower, discoveryTickUpper, discoveryEth, discoveryKraiken);
                 previousRow = row;
             });
         }
 
-        function simulate(precedingAction, currentTick, floorTickLower, floorTickUpper, floorEth, floorHarb, anchorTickLower, anchorTickUpper, anchorEth, anchorHarb, discoveryTickLower, discoveryTickUpper, discoveryEth, discoveryHarb) {
-            var tick_starts = [discoveryTickLower, anchorTickLower, floorTickLower];
-            var tick_ends = [discoveryTickUpper, anchorTickUpper, floorTickUpper];
-            var liquidity = [
-                discoveryEth + discoveryHarb,
-                anchorEth + anchorHarb,
-                floorEth + floorHarb
-            ];
-            var eth = [discoveryEth, anchorEth, floorEth];
-            var harb = [discoveryHarb, anchorHarb, floorHarb];
-
-            var widths = tick_ends.map((end, i) => end - tick_starts[i]);
-
-            var data = [
-                {
-                    x: tick_starts.map((start, i) => start + widths[i] / 2),
-                    y: harb,
-                    width: widths,
-                    type: 'bar',
-                    marker: {
-                        color: ['green', 'red', 'blue'],
-                        opacity: 0.6
-                    },
-                    text: harb.map((h, i) => `ETH: ${eth[i].toFixed(18)}<br>HARB: ${h.toFixed(18)}<br>Range: [${tick_starts[i]}, ${tick_ends[i]}]`),
-                    hoverinfo: 'text',
-                    name: 'Liquidity'
-                },
-                {
-                    x: [currentTick, currentTick],
-                    y: [0, Math.max(...harb) * 1.1],
-                    mode: 'lines',
-                    line: {
-                        color: 'black',
-                        width: 2,
-                        dash: 'dash'
-                    },
-                    name: 'Current Tick',
-                    hoverinfo: 'x',
-                    text: [`Current Price: ${currentTick}`]
-                }
-            ];
-
-            var layout = {
-                title: `Liquidity, ETH, and HARB Distribution - ${precedingAction}`,
-                xaxis: {
-                    title: 'Ticks',
-                    tickvals: tick_starts.concat([currentTick], tick_ends),
-                    ticktext: tick_starts.map(String).concat([`${currentTick}\n(Current Price)`], tick_ends.map(String))
-                },
-                yaxis: {
-                    title: 'Liquidity (HARB)'
-                }
-            };
-
-            var newDiv = document.createElement('div');
-            newDiv.className = 'chart-container';
-            var newHeader = document.createElement('h3');
-            newHeader.textContent = precedingAction;
-            var newChart = document.createElement('div');
-            newChart.style.width = '100%';
-            newChart.style.height = '600px';
-            var toggleButton = document.createElement('button');
-            toggleButton.textContent = 'Toggle ETH/HARB';
-            toggleButton.setAttribute('data-isethdisplayed', 'false');
-            toggleButton.onclick = function() { toggleData(newChart, eth, harb, tick_starts, tick_ends, widths, currentTick, precedingAction, toggleButton); };
-            newDiv.appendChild(newHeader);
-            newDiv.appendChild(toggleButton);
-            newDiv.appendChild(newChart);
-            document.getElementById('simulations').appendChild(newDiv);
-
-            Plotly.newPlot(newChart, data, layout);
+        // Uniswap V3 liquidity calculation functions
+        function tickToPrice(tick) {
+            return Math.pow(1.0001, tick);
         }
 
-        function toggleData(chart, eth, harb, tick_starts, tick_ends, widths, currentTick, precedingAction, button) {
-            var isETHDisplayed = button.getAttribute('data-isethdisplayed') === 'true';
-            var currentData = isETHDisplayed ? harb : eth;
-            var data = [
-                {
-                    x: tick_starts.map((start, i) => start + widths[i] / 2),
-                    y: currentData,
-                    width: widths,
-                    type: 'bar',
-                    marker: {
-                        color: ['green', 'red', 'blue'],
-                        opacity: 0.6
-                    },
-                    text: currentData.map((value, i) => `ETH: ${eth[i].toFixed(18)}<br>HARB: ${harb[i].toFixed(18)}<br>Range: [${tick_starts[i]}, ${tick_ends[i]}]`),
-                    hoverinfo: 'text',
-                    name: 'Liquidity'
-                },
-                {
-                    x: [currentTick, currentTick],
-                    y: [0, Math.max(...currentData) * 1.1],
-                    mode: 'lines',
-                    line: {
-                        color: 'black',
-                        width: 2,
-                        dash: 'dash'
-                    },
-                    name: 'Current Tick',
-                    hoverinfo: 'x',
-                    text: [`Current Price: ${currentTick}`]
-                }
-            ];
+        function priceToSqrtPrice(price) {
+            return Math.sqrt(price);
+        }
 
-            var layout = {
-                title: `Liquidity, ${isETHDisplayed ? 'HARB' : 'ETH'}, and ${isETHDisplayed ? 'ETH' : 'HARB'} Distribution - ${precedingAction}`,
-                xaxis: {
-                    title: 'Ticks',
-                    tickvals: tick_starts.concat([currentTick], tick_ends),
-                    ticktext: tick_starts.map(String).concat([`${currentTick}\n(Current Price)`], tick_ends.map(String))
+        function calculateUniV3Liquidity(token0Amount, token1Amount, tickLower, tickUpper, currentTick) {
+            const priceLower = tickToPrice(tickLower);
+            const priceUpper = tickToPrice(tickUpper);
+            const priceCurrent = tickToPrice(currentTick);
+            
+            const sqrtPriceLower = priceToSqrtPrice(priceLower);
+            const sqrtPriceUpper = priceToSqrtPrice(priceUpper);
+            const sqrtPriceCurrent = priceToSqrtPrice(priceCurrent);
+            
+            // Handle edge cases where denominators would be zero
+            if (sqrtPriceUpper === sqrtPriceLower) {
+                return 0; // Invalid range
+            }
+            
+            if (priceCurrent <= priceLower) {
+                // Price below range - position holds only token0 (ETH)
+                // Calculate liquidity from ETH amount using the full price range
+                if (token0Amount > 0) {
+                    return token0Amount * (sqrtPriceUpper * sqrtPriceLower) / (sqrtPriceUpper - sqrtPriceLower);
+                }
+                return 0;
+            } else if (priceCurrent >= priceUpper) {
+                // Price above range - position holds only token1 (KRAIKEN)  
+                // Calculate liquidity from KRAIKEN amount using the full price range
+                if (token1Amount > 0) {
+                    return token1Amount / (sqrtPriceUpper - sqrtPriceLower);
+                }
+                return 0;
+            } else {
+                // Price within range - calculate from both tokens and take minimum
+                let liquidityFromToken0 = 0;
+                let liquidityFromToken1 = 0;
+                
+                if (token0Amount > 0 && sqrtPriceUpper > sqrtPriceCurrent) {
+                    liquidityFromToken0 = token0Amount * (sqrtPriceUpper * sqrtPriceCurrent) / (sqrtPriceUpper - sqrtPriceCurrent);
+                }
+                
+                if (token1Amount > 0 && sqrtPriceCurrent > sqrtPriceLower) {
+                    liquidityFromToken1 = token1Amount / (sqrtPriceCurrent - sqrtPriceLower);
+                }
+                
+                // Return the non-zero value, or minimum if both are present
+                if (liquidityFromToken0 > 0 && liquidityFromToken1 > 0) {
+                    return Math.min(liquidityFromToken0, liquidityFromToken1);
+                }
+                return Math.max(liquidityFromToken0, liquidityFromToken1);
+            }
+        }
+
+        function simulateEnhanced(precedingAction, currentTick, 
+            floorTickLower, floorTickUpper, floorEth, floorKraiken, 
+            anchorTickLower, anchorTickUpper, anchorEth, anchorKraiken, 
+            discoveryTickLower, discoveryTickUpper, discoveryEth, discoveryKraiken) {
+            
+            // Position data structure with liquidity calculations
+            const positions = {
+                floor: {
+                    tickLower: floorTickLower,
+                    tickUpper: floorTickUpper,
+                    eth: floorEth,
+                    kraiken: floorKraiken,
+                    name: 'Floor (ETH Reserve)',
+                    liquidity: ethIsToken0 ? 
+                        calculateUniV3Liquidity(floorEth, floorKraiken, floorTickLower, floorTickUpper, currentTick) :
+                        calculateUniV3Liquidity(floorKraiken, floorEth, floorTickLower, floorTickUpper, currentTick)
                 },
-                yaxis: {
-                    title: `Liquidity (${isETHDisplayed ? 'HARB' : 'ETH'})`
+                anchor: {
+                    tickLower: anchorTickLower,
+                    tickUpper: anchorTickUpper,
+                    eth: anchorEth,
+                    kraiken: anchorKraiken,
+                    name: 'Anchor (Shallow Pool)',
+                    liquidity: ethIsToken0 ? 
+                        calculateUniV3Liquidity(anchorEth, anchorKraiken, anchorTickLower, anchorTickUpper, currentTick) :
+                        calculateUniV3Liquidity(anchorKraiken, anchorEth, anchorTickLower, anchorTickUpper, currentTick)
+                },
+                discovery: {
+                    tickLower: discoveryTickLower,
+                    tickUpper: discoveryTickUpper,
+                    eth: discoveryEth,
+                    kraiken: discoveryKraiken,
+                    name: 'Discovery (KRAIKEN Mint)',
+                    liquidity: ethIsToken0 ? 
+                        calculateUniV3Liquidity(discoveryEth, discoveryKraiken, discoveryTickLower, discoveryTickUpper, currentTick) :
+                        calculateUniV3Liquidity(discoveryKraiken, discoveryEth, discoveryTickLower, discoveryTickUpper, currentTick)
                 }
             };
 
-            button.setAttribute('data-isethdisplayed', (!isETHDisplayed).toString());
-            Plotly.react(chart, data, layout);  // Use Plotly.react to update the existing chart
+            // Calculate total active liquidity
+            const totalLiquidity = Object.values(positions).reduce((sum, pos) => sum + pos.liquidity, 0);
+
+            // Create container for this scenario
+            const scenarioContainer = document.createElement('div');
+            scenarioContainer.className = 'scenario-container';
+
+            // Create header
+            const header = document.createElement('div');
+            header.className = 'scenario-header';
+            header.innerHTML = `<h3>${precedingAction}</h3>`;
+            scenarioContainer.appendChild(header);
+
+            // Create legend
+            const legend = document.createElement('div');
+            legend.className = 'legend';
+            legend.innerHTML = `
+                <div class="legend-item">
+                    <div class="legend-color floor"></div>
+                    <span>Floor Position (Foundation)</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color anchor"></div>
+                    <span>Anchor Position (Current Price)</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color discovery"></div>
+                    <span>Discovery Position (Growth)</span>
+                </div>
+            `;
+            scenarioContainer.appendChild(legend);
+
+            // Create charts container
+            const chartsContainer = document.createElement('div');
+            chartsContainer.className = 'charts-container';
+
+            // Create combined chart
+            const chartWrapper = document.createElement('div');
+            chartWrapper.className = 'chart-wrapper';
+            chartWrapper.style.width = '100%'; // Full width for single chart
+            const chartTitle = document.createElement('div');
+            chartTitle.className = 'chart-title';
+            chartTitle.textContent = 'Token Distribution by Position';
+            const combinedChart = document.createElement('div');
+            combinedChart.className = 'chart-div';
+            combinedChart.id = `combined-chart-${Date.now()}-${Math.random()}`;
+            chartWrapper.appendChild(chartTitle);
+            chartWrapper.appendChild(combinedChart);
+
+            chartsContainer.appendChild(chartWrapper);
+            scenarioContainer.appendChild(chartsContainer);
+
+            // Create summary panel
+            const summaryPanel = createSummaryPanel(positions, currentTick);
+            scenarioContainer.appendChild(summaryPanel);
+
+            // Add to page
+            document.getElementById('simulations').appendChild(scenarioContainer);
+
+            // Create the combined chart
+            createCombinedChart(combinedChart, positions, currentTick, totalLiquidity);
+        }
+
+        function createCombinedChart(chartDiv, positions, currentTick, totalLiquidity) {
+            const positionKeys = ['floor', 'anchor', 'discovery'];
+            
+            // Calculate bar widths to represent actual tick ranges
+            const barWidths = positionKeys.map(key => {
+                const pos = positions[key];
+                return pos.tickUpper - pos.tickLower; // Width = actual tick range
+            });
+
+            // Calculate bar positions (centered in tick ranges)
+            const barPositions = positionKeys.map(key => {
+                const pos = positions[key];
+                return pos.tickLower + (pos.tickUpper - pos.tickLower) / 2;
+            });
+
+            // ETH trace (left y-axis)
+            const ethTrace = {
+                x: barPositions,
+                y: positionKeys.map(key => positions[key].eth),
+                width: barWidths,
+                type: 'bar',
+                name: 'ETH',
+                yaxis: 'y',
+                marker: {
+                    color: positionKeys.map(key => POSITION_COLORS[key]),
+                    opacity: 0.7,
+                    line: {
+                        color: 'white',
+                        width: 2
+                    }
+                },
+                text: positionKeys.map(key => {
+                    const pos = positions[key];
+                    return `${pos.name}<br>ETH: ${pos.eth.toFixed(6)}<br>Range: [${pos.tickLower}, ${pos.tickUpper}]`;
+                }),
+                hoverinfo: 'text'
+            };
+
+            // KRAIKEN trace (right y-axis)
+            const kraikenTrace = {
+                x: barPositions, // Same position as ETH bars
+                y: positionKeys.map(key => positions[key].kraiken),
+                width: barWidths,
+                type: 'bar',
+                name: 'KRAIKEN',
+                yaxis: 'y2',
+                marker: {
+                    color: positionKeys.map(key => POSITION_COLORS[key]),
+                    opacity: 0.4,
+                    pattern: {
+                        shape: '/',
+                        size: 8
+                    },
+                    line: {
+                        color: 'white',
+                        width: 2
+                    }
+                },
+                text: positionKeys.map(key => {
+                    const pos = positions[key];
+                    return `${pos.name}<br>KRAIKEN: ${pos.kraiken.toFixed(6)}<br>Range: [${pos.tickLower}, ${pos.tickUpper}]`;
+                }),
+                hoverinfo: 'text'
+            };
+
+            // Calculate x-axis range based on position ranges with some padding
+            const allTicks = positionKeys.flatMap(key => [positions[key].tickLower, positions[key].tickUpper]);
+            const minTick = Math.min(...allTicks);
+            const maxTick = Math.max(...allTicks);
+            const tickRange = maxTick - minTick;
+            const padding = tickRange * 0.1; // 10% padding on each side
+            const xAxisMin = minTick - padding;
+            const xAxisMax = maxTick + padding;
+
+            // Calculate max values for proper y-axis alignment
+            const maxEth = Math.max(...positionKeys.map(key => positions[key].eth));
+            const maxKraiken = Math.max(...positionKeys.map(key => positions[key].kraiken));
+            const showPriceLine = currentTick >= xAxisMin && currentTick <= xAxisMax;
+            
+            const data = [ethTrace, kraikenTrace];
+            
+            if (showPriceLine) {
+                const priceLineTrace = {
+                    x: [currentTick, currentTick],
+                    y: [0, maxEth * 1.1],
+                    mode: 'lines',
+                    line: {
+                        color: 'red',
+                        width: 3,
+                        dash: 'dash'
+                    },
+                    name: 'Current Price',
+                    yaxis: 'y',
+                    hoverinfo: 'x',
+                    text: [`Current Price: ${currentTick}`],
+                    showlegend: true
+                };
+                data.push(priceLineTrace);
+            }
+
+            const layout = {
+                title: {
+                    text: `Token Distribution by Position (Current Price: ${currentTick}${showPriceLine ? '' : ' - Outside Range'})`,
+                    font: { size: 16 }
+                },
+                xaxis: {
+                    title: 'Price Ticks',
+                    showgrid: true,
+                    gridcolor: '#e0e0e0',
+                    range: [xAxisMin, xAxisMax]
+                },
+                yaxis: {
+                    title: 'ETH Amount',
+                    side: 'left',
+                    showgrid: true,
+                    gridcolor: '#e0e0e0',
+                    titlefont: { color: '#1f77b4' },
+                    tickfont: { color: '#1f77b4' },
+                    range: [0, maxEth * 1.1] // Start from 0, add 10% padding
+                },
+                yaxis2: {
+                    title: 'KRAIKEN Amount',
+                    side: 'right',
+                    overlaying: 'y',
+                    showgrid: false,
+                    titlefont: { color: '#ff7f0e' },
+                    tickfont: { color: '#ff7f0e' },
+                    range: [0, maxKraiken * 1.1] // Start from 0, add 10% padding
+                },
+                showlegend: true,
+                legend: {
+                    x: 0.02,
+                    y: 0.98,
+                    bgcolor: 'rgba(255,255,255,0.8)',
+                    bordercolor: '#ccc',
+                    borderwidth: 1
+                },
+                plot_bgcolor: 'white',
+                paper_bgcolor: 'white',
+                margin: { l: 60, r: 60, t: 60, b: 50 }
+            };
+
+            Plotly.newPlot(chartDiv, data, layout, {responsive: true});
+        }
+
+        function createDualCharts(ethChartDiv, kraikenChartDiv, positions, currentTick, totalLiquidity) {
+            const positionKeys = ['floor', 'anchor', 'discovery'];
+            
+            // Calculate bar widths proportional to actual Uniswap V3 liquidity
+            const baseWidth = 50; // Base width for tick ranges
+            const barWidths = positionKeys.map(key => {
+                const pos = positions[key];
+                const liquidityRatio = totalLiquidity > 0 ? pos.liquidity / totalLiquidity : 0;
+                return Math.max(baseWidth * 0.3, baseWidth * liquidityRatio * 3); // Scale for visibility
+            });
+
+            // Calculate bar positions (centered in tick ranges)
+            const barPositions = positionKeys.map(key => {
+                const pos = positions[key];
+                return pos.tickLower + (pos.tickUpper - pos.tickLower) / 2;
+            });
+
+            // ETH Chart Data
+            const ethData = [{
+                x: barPositions,
+                y: positionKeys.map(key => positions[key].eth),
+                width: barWidths,
+                type: 'bar',
+                marker: {
+                    color: positionKeys.map(key => POSITION_COLORS[key]),
+                    opacity: 0.8,
+                    line: {
+                        color: 'white',
+                        width: 2
+                    }
+                },
+                text: positionKeys.map(key => {
+                    const pos = positions[key];
+                    let tooltip = `${pos.name} Position<br>`;
+                    
+                    // Show token amounts and actual Uniswap V3 liquidity
+                    tooltip += `ETH: ${pos.eth.toFixed(6)}<br>KRAIKEN: ${pos.kraiken.toFixed(6)}`;
+                    tooltip += `<br>Uniswap V3 Liquidity: ${pos.liquidity.toFixed(2)}`;
+                    tooltip += `<br>Range: [${pos.tickLower}, ${pos.tickUpper}]`;
+                    return tooltip;
+                }),
+                hoverinfo: 'text',
+                name: 'ETH Liquidity'
+            }];
+
+            // Kraiken Chart Data
+            const kraikenData = [{
+                x: barPositions,
+                y: positionKeys.map(key => positions[key].kraiken),
+                width: barWidths,
+                type: 'bar',
+                marker: {
+                    color: positionKeys.map(key => POSITION_COLORS[key]),
+                    opacity: 0.8,
+                    line: {
+                        color: 'white',
+                        width: 2
+                    }
+                },
+                text: positionKeys.map(key => {
+                    const pos = positions[key];
+                    let tooltip = `${pos.name} Position<br>`;
+                    
+                    // Show token amounts and actual Uniswap V3 liquidity
+                    tooltip += `ETH: ${pos.eth.toFixed(6)}<br>KRAIKEN: ${pos.kraiken.toFixed(6)}`;
+                    tooltip += `<br>Uniswap V3 Liquidity: ${pos.liquidity.toFixed(2)}`;
+                    tooltip += `<br>Range: [${pos.tickLower}, ${pos.tickUpper}]`;
+                    return tooltip;
+                }),
+                hoverinfo: 'text',
+                name: 'KRAIKEN Liquidity'
+            }];
+
+            // Add current price line to both charts
+            const maxEth = Math.max(...positionKeys.map(key => positions[key].eth));
+            const maxKraiken = Math.max(...positionKeys.map(key => positions[key].kraiken));
+
+            const priceLineEth = {
+                x: [currentTick, currentTick],
+                y: [0, maxEth * 1.1],
+                mode: 'lines',
+                line: {
+                    color: 'red',
+                    width: 3,
+                    dash: 'dash'
+                },
+                name: 'Current Price',
+                hoverinfo: 'x',
+                text: [`Current Price: ${currentTick}`]
+            };
+
+            const priceLineKraiken = {
+                x: [currentTick, currentTick],
+                y: [0, maxKraiken * 1.1],
+                mode: 'lines',
+                line: {
+                    color: 'red',
+                    width: 3,
+                    dash: 'dash'
+                },
+                name: 'Current Price',
+                hoverinfo: 'x',
+                text: [`Current Price: ${currentTick}`]
+            };
+
+            ethData.push(priceLineEth);
+            kraikenData.push(priceLineKraiken);
+
+            // Create synchronized layouts
+            const ethLayout = {
+                title: {
+                    text: 'ETH Liquidity by Position',
+                    font: { size: 16 }
+                },
+                xaxis: {
+                    title: 'Price Ticks',
+                    showgrid: true,
+                    gridcolor: '#e0e0e0'
+                },
+                yaxis: {
+                    title: 'ETH Amount',
+                    showgrid: true,
+                    gridcolor: '#e0e0e0'
+                },
+                showlegend: false,
+                plot_bgcolor: 'white',
+                paper_bgcolor: 'white',
+                margin: { l: 60, r: 30, t: 60, b: 50 }
+            };
+
+            const kraikenLayout = {
+                title: {
+                    text: 'KRAIKEN Liquidity by Position',
+                    font: { size: 16 }
+                },
+                xaxis: {
+                    title: 'Price Ticks',
+                    showgrid: true,
+                    gridcolor: '#e0e0e0'
+                },
+                yaxis: {
+                    title: 'KRAIKEN Amount',
+                    showgrid: true,
+                    gridcolor: '#e0e0e0'
+                },
+                showlegend: false,
+                plot_bgcolor: 'white',
+                paper_bgcolor: 'white',
+                margin: { l: 60, r: 30, t: 60, b: 50 }
+            };
+
+            // Plot both charts
+            Plotly.newPlot(ethChartDiv, ethData, ethLayout, {responsive: true});
+            Plotly.newPlot(kraikenChartDiv, kraikenData, kraikenLayout, {responsive: true});
+
+            // Add synchronized interactions
+            synchronizeCharts(ethChartDiv, kraikenChartDiv);
+        }
+
+        function synchronizeCharts(chart1, chart2) {
+            // Synchronize hover events
+            chart1.on('plotly_hover', function(data) {
+                if (data.points && data.points[0] && data.points[0].pointNumber !== undefined) {
+                    const pointIndex = data.points[0].pointNumber;
+                    Plotly.Fx.hover(chart2, [{curveNumber: 0, pointNumber: pointIndex}]);
+                }
+            });
+
+            chart2.on('plotly_hover', function(data) {
+                if (data.points && data.points[0] && data.points[0].pointNumber !== undefined) {
+                    const pointIndex = data.points[0].pointNumber;
+                    Plotly.Fx.hover(chart1, [{curveNumber: 0, pointNumber: pointIndex}]);
+                }
+            });
+
+            // Synchronize unhover events
+            chart1.on('plotly_unhover', function() {
+                Plotly.Fx.unhover(chart2);
+            });
+
+            chart2.on('plotly_unhover', function() {
+                Plotly.Fx.unhover(chart1);
+            });
+        }
+
+        function createSummaryPanel(positions, currentTick) {
+            const panel = document.createElement('div');
+            panel.className = 'summary-panel';
+
+            const title = document.createElement('h4');
+            title.textContent = 'Position Summary';
+            title.style.margin = '0 0 15px 0';
+            panel.appendChild(title);
+
+            const grid = document.createElement('div');
+            grid.className = 'summary-grid';
+
+            // Calculate totals
+            const totalEth = Object.values(positions).reduce((sum, pos) => sum + pos.eth, 0);
+            const totalKraiken = Object.values(positions).reduce((sum, pos) => sum + pos.kraiken, 0);
+            const totalUniV3Liquidity = Object.values(positions).reduce((sum, pos) => sum + pos.liquidity, 0);
+
+            // Add total summary
+            const totalItem = document.createElement('div');
+            totalItem.className = 'summary-item';
+            totalItem.innerHTML = `
+                <strong>Total Portfolio</strong><br>
+                Token ETH: ${totalEth.toFixed(6)}<br>
+                Token KRAIKEN: ${totalKraiken.toFixed(6)}<br>
+                Uniswap V3 Liquidity: ${totalUniV3Liquidity.toFixed(2)}
+            `;
+            grid.appendChild(totalItem);
+
+            // Add position summaries
+            Object.entries(positions).forEach(([key, pos]) => {
+                const item = document.createElement('div');
+                item.className = `summary-item ${key}`;
+                
+                // Calculate position-specific liquidity percentage
+                const liquidityPercent = totalUniV3Liquidity > 0 ? (pos.liquidity / totalUniV3Liquidity * 100).toFixed(1) : '0.0';
+                const tickRange = pos.tickUpper - pos.tickLower;
+                
+                item.innerHTML = `
+                    <strong>${pos.name} Position</strong><br>
+                    ETH: ${pos.eth.toFixed(6)}<br>
+                    KRAIKEN: ${pos.kraiken.toFixed(6)}<br>
+                    Uniswap V3 Liquidity: ${pos.liquidity.toFixed(2)} (${liquidityPercent}%)<br>
+                    Range: ${tickRange} ticks
+                `;
+                grid.appendChild(item);
+            });
+
+            // Add current price info
+            const priceItem = document.createElement('div');
+            priceItem.className = 'summary-item';
+            priceItem.innerHTML = `
+                <strong>Current Price</strong><br>
+                Tick: ${currentTick}<br>
+                <small>Price line shown in red</small>
+            `;
+            grid.appendChild(priceItem);
+
+            panel.appendChild(grid);
+            return panel;
         }
     </script>
 </body>
-</html>
-
+</html>
\ No newline at end of file
diff --git a/onchain/src/abstracts/ThreePositionStrategy.sol b/onchain/src/abstracts/ThreePositionStrategy.sol
index d8351ca..08c432d 100644
--- a/onchain/src/abstracts/ThreePositionStrategy.sol
+++ b/onchain/src/abstracts/ThreePositionStrategy.sol
@@ -146,9 +146,9 @@ abstract contract ThreePositionStrategy is UniswapMath, VWAPTracker {
         
         uint128 liquidity;
         if (token0isWeth) {
-            liquidity = LiquidityAmounts.getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, discoveryAmount);
-        } else {
             liquidity = LiquidityAmounts.getLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, discoveryAmount);
+        } else {
+            liquidity = LiquidityAmounts.getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, discoveryAmount);
         }
         
         _mintPosition(Stage.DISCOVERY, tickLower, tickUpper, liquidity);
@@ -220,9 +220,9 @@ abstract contract ThreePositionStrategy is UniswapMath, VWAPTracker {
         uint256 finalEthBalance = _getEthBalance(); // Refresh balance
         
         if (token0isWeth) {
-            liquidity = LiquidityAmounts.getLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, finalEthBalance);
-        } else {
             liquidity = LiquidityAmounts.getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, finalEthBalance);
+        } else {
+            liquidity = LiquidityAmounts.getLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, finalEthBalance);
         }
         
         _mintPosition(Stage.FLOOR, token0isWeth ? vwapTick : floorTick, token0isWeth ? floorTick : vwapTick, liquidity);