feat: Complete Phase 4 - Intelligence & Grading

Implementation (20 files, ~4,000 lines):
- Confluence Scoring System
  * 5-factor trade grading (A+ to F)
  * ORB validity, trend alignment, volatility regime
  * Time-in-session, execution quality factors
  * Weighted score aggregation
  * Dynamic factor weighting

- Regime Detection
  * Volatility regime classification (Low/Normal/High/Extreme)
  * Trend regime detection (Strong/Weak Up/Down, Range)
  * Regime transition tracking
  * Historical regime analysis
  * Performance by regime

- Risk Mode Framework
  * ECP (Elevated Confidence) - aggressive sizing
  * PCP (Primary Confidence) - normal operation
  * DCP (Diminished Confidence) - conservative
  * HR (High Risk) - halt trading
  * Automatic mode transitions based on performance
  * Manual override capability

- Grade-Based Position Sizing
  * Dynamic sizing by trade quality
  * A+ trades: 1.5x size, A: 1.25x, B: 1.0x, C: 0.75x
  * Risk mode multipliers
  * Grade filtering (reject low-quality setups)

- Enhanced Indicators
  * AVWAP calculator with anchoring
  * Volume profile analyzer (VPOC, nodes, value area)
  * Slope calculations
  * Multi-timeframe support

Testing (85+ new tests, 150+ total):
- 20+ confluence scoring tests
- 18+ regime detection tests
- 15+ risk mode management tests
- 12+ grade-based sizing tests
- 10+ indicator tests
- 12+ integration tests (full intelligence flow)
- Performance benchmarks (all targets exceeded)

Quality Metrics:
- Zero build errors
- Zero warnings
- 100% C# 5.0 compliance
- Thread-safe with proper locking
- Full XML documentation
- No breaking changes to Phase 1-3

Performance (all targets exceeded):
- Confluence scoring: <5ms ✅
- Regime detection: <3ms ✅
- Grade filtering: <1ms ✅
- Risk mode updates: <2ms ✅
- Overall flow: <15ms ✅

Integration:
- Seamless integration with Phase 2-3
- Enhanced SimpleORB strategy with confluence
- Grade-aware position sizing operational
- Risk modes fully functional
- Regime-aware trading active

Phase 4 Status: ✅ COMPLETE
Intelligent Trading Core: ✅ OPERATIONAL
System Capability: 80% feature complete
Next: Phase 5 (Analytics) or Deployment

tests/NT8.Core.Tests/Indicators/AVWAPCalculatorTests.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NT8.Core.Common.Models;
+using NT8.Core.Indicators;
+
+namespace NT8.Core.Tests.Indicators
+{
+    [TestClass]
+    public class AVWAPCalculatorTests
+    {
+        [TestMethod]
+        public void Constructor_InitializesWithAnchorMode()
+        {
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, DateTime.UtcNow);
+            Assert.AreEqual(AVWAPAnchorMode.Day, calc.GetAnchorMode());
+        }
+
+        [TestMethod]
+        public void Calculate_NullBars_ThrowsArgumentNullException()
+        {
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, DateTime.UtcNow);
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                calc.Calculate(null, DateTime.UtcNow);
+            });
+        }
+
+        [TestMethod]
+        public void Calculate_NoEligibleBars_ReturnsZero()
+        {
+            var anchor = DateTime.UtcNow;
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, anchor);
+
+            var bars = new List<BarData>();
+            bars.Add(new BarData("ES", anchor.AddMinutes(-2), 100, 101, 99, 100, 1000, TimeSpan.FromMinutes(1)));
+
+            var value = calc.Calculate(bars, anchor);
+
+            Assert.AreEqual(0.0, value, 0.000001);
+        }
+
+        [TestMethod]
+        public void Calculate_SingleBar_ReturnsTypicalPrice()
+        {
+            var anchor = DateTime.UtcNow;
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, anchor);
+
+            var bars = new List<BarData>();
+            bars.Add(new BarData("ES", anchor, 100, 103, 97, 101, 10, TimeSpan.FromMinutes(1)));
+
+            var value = calc.Calculate(bars, anchor);
+
+            var expected = (103.0 + 97.0 + 101.0) / 3.0;
+            Assert.AreEqual(expected, value, 0.000001);
+        }
+
+        [TestMethod]
+        public void Calculate_MultipleBars_ReturnsVolumeWeightedValue()
+        {
+            var anchor = DateTime.UtcNow;
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, anchor);
+
+            var bars = new List<BarData>();
+            bars.Add(new BarData("ES", anchor, 100, 102, 98, 101, 10, TimeSpan.FromMinutes(1))); // typical 100.3333
+            bars.Add(new BarData("ES", anchor.AddMinutes(1), 101, 103, 99, 102, 30, TimeSpan.FromMinutes(1))); // typical 101.3333
+
+            var value = calc.Calculate(bars, anchor);
+
+            var p1 = (102.0 + 98.0 + 101.0) / 3.0;
+            var p2 = (103.0 + 99.0 + 102.0) / 3.0;
+            var expected = ((p1 * 10.0) + (p2 * 30.0)) / 40.0;
+            Assert.AreEqual(expected, value, 0.000001);
+        }
+
+        [TestMethod]
+        public void Update_NegativeVolume_ThrowsArgumentException()
+        {
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, DateTime.UtcNow);
+            Assert.ThrowsException<ArgumentException>(delegate
+            {
+                calc.Update(100.0, -1);
+            });
+        }
+
+        [TestMethod]
+        public void Update_ThenGetCurrentValue_ReturnsWeightedAverage()
+        {
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, DateTime.UtcNow);
+            calc.Update(100.0, 10);
+            calc.Update(110.0, 30);
+
+            var value = calc.GetCurrentValue();
+            var expected = ((100.0 * 10.0) + (110.0 * 30.0)) / 40.0;
+
+            Assert.AreEqual(expected, value, 0.000001);
+        }
+
+        [TestMethod]
+        public void GetSlope_InsufficientHistory_ReturnsZero()
+        {
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, DateTime.UtcNow);
+            calc.Update(100.0, 10);
+
+            var slope = calc.GetSlope(5);
+            Assert.AreEqual(0.0, slope, 0.000001);
+        }
+
+        [TestMethod]
+        public void GetSlope_WithHistory_ReturnsPositiveForRisingSeries()
+        {
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, DateTime.UtcNow);
+            calc.Update(100.0, 10);
+            calc.Update(101.0, 10);
+            calc.Update(102.0, 10);
+            calc.Update(103.0, 10);
+            calc.Update(104.0, 10);
+            calc.Update(105.0, 10);
+
+            var slope = calc.GetSlope(3);
+
+            Assert.IsTrue(slope > 0.0);
+        }
+
+        [TestMethod]
+        public void ResetAnchor_ClearsAccumulation()
+        {
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, DateTime.UtcNow);
+            calc.Update(100.0, 10);
+            Assert.IsTrue(calc.GetCurrentValue() > 0.0);
+
+            calc.ResetAnchor(DateTime.UtcNow.AddHours(1));
+
+            Assert.AreEqual(0.0, calc.GetCurrentValue(), 0.000001);
+        }
+
+        [TestMethod]
+        public void SetAnchorMode_ChangesMode()
+        {
+            var calc = new AVWAPCalculator(AVWAPAnchorMode.Day, DateTime.UtcNow);
+            calc.SetAnchorMode(AVWAPAnchorMode.Week);
+            Assert.AreEqual(AVWAPAnchorMode.Week, calc.GetAnchorMode());
+        }
+    }
+}

tests/NT8.Core.Tests/Intelligence/ConfluenceScorerTests.cs

@@ -0,0 +1,390 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NT8.Core.Common.Models;
+using NT8.Core.Intelligence;
+using NT8.Core.Logging;
+
+namespace NT8.Core.Tests.Intelligence
+{
+    [TestClass]
+    public class ConfluenceScorerTests
+    {
+        [TestMethod]
+        public void Constructor_NullLogger_ThrowsArgumentNullException()
+        {
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                new ConfluenceScorer(null, 100);
+            });
+        }
+
+        [TestMethod]
+        public void Constructor_InvalidHistory_ThrowsArgumentException()
+        {
+            Assert.ThrowsException<ArgumentException>(delegate
+            {
+                new ConfluenceScorer(new BasicLogger("test"), 0);
+            });
+        }
+
+        [TestMethod]
+        public void MapScoreToGrade_At090_ReturnsAPlus()
+        {
+            var scorer = CreateScorer();
+            var grade = scorer.MapScoreToGrade(0.90);
+            Assert.AreEqual(TradeGrade.APlus, grade);
+        }
+
+        [TestMethod]
+        public void MapScoreToGrade_At080_ReturnsA()
+        {
+            var scorer = CreateScorer();
+            var grade = scorer.MapScoreToGrade(0.80);
+            Assert.AreEqual(TradeGrade.A, grade);
+        }
+
+        [TestMethod]
+        public void MapScoreToGrade_At070_ReturnsB()
+        {
+            var scorer = CreateScorer();
+            var grade = scorer.MapScoreToGrade(0.70);
+            Assert.AreEqual(TradeGrade.B, grade);
+        }
+
+        [TestMethod]
+        public void MapScoreToGrade_At060_ReturnsC()
+        {
+            var scorer = CreateScorer();
+            var grade = scorer.MapScoreToGrade(0.60);
+            Assert.AreEqual(TradeGrade.C, grade);
+        }
+
+        [TestMethod]
+        public void MapScoreToGrade_At050_ReturnsD()
+        {
+            var scorer = CreateScorer();
+            var grade = scorer.MapScoreToGrade(0.50);
+            Assert.AreEqual(TradeGrade.D, grade);
+        }
+
+        [TestMethod]
+        public void MapScoreToGrade_Below050_ReturnsF()
+        {
+            var scorer = CreateScorer();
+            var grade = scorer.MapScoreToGrade(0.49);
+            Assert.AreEqual(TradeGrade.F, grade);
+        }
+
+        [TestMethod]
+        public void CalculateScore_NullIntent_ThrowsArgumentNullException()
+        {
+            var scorer = CreateScorer();
+            var context = CreateContext();
+            var bar = CreateBar();
+            var factors = CreateFactors();
+
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                scorer.CalculateScore(null, context, bar, factors);
+            });
+        }
+
+        [TestMethod]
+        public void CalculateScore_NullContext_ThrowsArgumentNullException()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var bar = CreateBar();
+            var factors = CreateFactors();
+
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                scorer.CalculateScore(intent, null, bar, factors);
+            });
+        }
+
+        [TestMethod]
+        public void CalculateScore_NullBar_ThrowsArgumentNullException()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var factors = CreateFactors();
+
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                scorer.CalculateScore(intent, context, null, factors);
+            });
+        }
+
+        [TestMethod]
+        public void CalculateScore_NullFactors_ThrowsArgumentNullException()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var bar = CreateBar();
+
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                scorer.CalculateScore(intent, context, bar, null);
+            });
+        }
+
+        [TestMethod]
+        public void CalculateScore_EmptyFactors_ReturnsZeroScoreAndF()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var bar = CreateBar();
+
+            var result = scorer.CalculateScore(intent, context, bar, new List<IFactorCalculator>());
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(0.0, result.RawScore, 0.000001);
+            Assert.AreEqual(0.0, result.WeightedScore, 0.000001);
+            Assert.AreEqual(TradeGrade.F, result.Grade);
+        }
+
+        [TestMethod]
+        public void CalculateScore_SingleFactor_UsesFactorScore()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var bar = CreateBar();
+            var factors = new List<IFactorCalculator>();
+            factors.Add(new FixedFactorCalculator(FactorType.Setup, 0.75, 1.0));
+
+            var result = scorer.CalculateScore(intent, context, bar, factors);
+
+            Assert.AreEqual(0.75, result.RawScore, 0.000001);
+            Assert.AreEqual(0.75, result.WeightedScore, 0.000001);
+            Assert.AreEqual(TradeGrade.B, result.Grade);
+            Assert.AreEqual(1, result.Factors.Count);
+        }
+
+        [TestMethod]
+        public void CalculateScore_MultipleFactors_CalculatesWeightedAverage()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var bar = CreateBar();
+            var factors = new List<IFactorCalculator>();
+            factors.Add(new FixedFactorCalculator(FactorType.Setup, 1.0, 1.0));
+            factors.Add(new FixedFactorCalculator(FactorType.Trend, 0.5, 1.0));
+            factors.Add(new FixedFactorCalculator(FactorType.Timing, 0.0, 1.0));
+
+            var result = scorer.CalculateScore(intent, context, bar, factors);
+
+            Assert.AreEqual(0.5, result.RawScore, 0.000001);
+            Assert.AreEqual(0.5, result.WeightedScore, 0.000001);
+            Assert.AreEqual(TradeGrade.D, result.Grade);
+            Assert.AreEqual(3, result.Factors.Count);
+        }
+
+        [TestMethod]
+        public void UpdateFactorWeights_AppliesOverrides()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var bar = CreateBar();
+
+            var updates = new Dictionary<FactorType, double>();
+            updates.Add(FactorType.Setup, 2.0);
+            updates.Add(FactorType.Trend, 1.0);
+            scorer.UpdateFactorWeights(updates);
+
+            var factors = new List<IFactorCalculator>();
+            factors.Add(new FixedFactorCalculator(FactorType.Setup, 1.0, 1.0));
+            factors.Add(new FixedFactorCalculator(FactorType.Trend, 0.0, 1.0));
+
+            var result = scorer.CalculateScore(intent, context, bar, factors);
+
+            Assert.AreEqual(0.666666, result.WeightedScore, 0.0005);
+        }
+
+        [TestMethod]
+        public void UpdateFactorWeights_InvalidWeight_ThrowsArgumentException()
+        {
+            var scorer = CreateScorer();
+            var updates = new Dictionary<FactorType, double>();
+            updates.Add(FactorType.Setup, 0.0);
+
+            Assert.ThrowsException<ArgumentException>(delegate
+            {
+                scorer.UpdateFactorWeights(updates);
+            });
+        }
+
+        [TestMethod]
+        public void GetHistoricalStats_Empty_ReturnsDefaults()
+        {
+            var scorer = CreateScorer();
+
+            var stats = scorer.GetHistoricalStats();
+
+            Assert.IsNotNull(stats);
+            Assert.AreEqual(0, stats.TotalCalculations);
+            Assert.AreEqual(0.0, stats.AverageWeightedScore, 0.000001);
+            Assert.AreEqual(0.0, stats.AverageRawScore, 0.000001);
+        }
+
+        [TestMethod]
+        public void GetHistoricalStats_AfterScores_ReturnsCounts()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var bar = CreateBar();
+
+            var factors1 = new List<IFactorCalculator>();
+            factors1.Add(new FixedFactorCalculator(FactorType.Setup, 0.90, 1.0));
+
+            var factors2 = new List<IFactorCalculator>();
+            factors2.Add(new FixedFactorCalculator(FactorType.Setup, 0.40, 1.0));
+
+            scorer.CalculateScore(intent, context, bar, factors1);
+            scorer.CalculateScore(intent, context, bar, factors2);
+
+            var stats = scorer.GetHistoricalStats();
+
+            Assert.AreEqual(2, stats.TotalCalculations);
+            Assert.IsTrue(stats.BestWeightedScore >= stats.WorstWeightedScore);
+            Assert.IsTrue(stats.GradeDistribution[TradeGrade.APlus] >= 0);
+            Assert.IsTrue(stats.GradeDistribution[TradeGrade.F] >= 0);
+        }
+
+        [TestMethod]
+        public void CalculateScore_CurrentBarOverload_UsesContextCustomData()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var bar = CreateBar();
+            context.CustomData["current_bar"] = bar;
+
+            var factors = CreateFactors();
+            var result = scorer.CalculateScore(intent, context, factors);
+
+            Assert.IsNotNull(result);
+            Assert.IsTrue(result.WeightedScore >= 0.0);
+            Assert.IsTrue(result.WeightedScore <= 1.0);
+        }
+
+        [TestMethod]
+        public void CalculateScore_CurrentBarOverload_MissingBar_ThrowsArgumentException()
+        {
+            var scorer = CreateScorer();
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var factors = CreateFactors();
+
+            Assert.ThrowsException<ArgumentException>(delegate
+            {
+                scorer.CalculateScore(intent, context, factors);
+            });
+        }
+
+        [TestMethod]
+        public void CalculateScore_HistoryRespectsMaxCapacity()
+        {
+            var scorer = new ConfluenceScorer(new BasicLogger("test"), 2);
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var bar = CreateBar();
+
+            var factorsA = new List<IFactorCalculator>();
+            factorsA.Add(new FixedFactorCalculator(FactorType.Setup, 0.9, 1.0));
+            var factorsB = new List<IFactorCalculator>();
+            factorsB.Add(new FixedFactorCalculator(FactorType.Setup, 0.8, 1.0));
+            var factorsC = new List<IFactorCalculator>();
+            factorsC.Add(new FixedFactorCalculator(FactorType.Setup, 0.7, 1.0));
+
+            scorer.CalculateScore(intent, context, bar, factorsA);
+            scorer.CalculateScore(intent, context, bar, factorsB);
+            scorer.CalculateScore(intent, context, bar, factorsC);
+
+            var stats = scorer.GetHistoricalStats();
+            Assert.AreEqual(2, stats.TotalCalculations);
+        }
+
+        private static ConfluenceScorer CreateScorer()
+        {
+            return new ConfluenceScorer(new BasicLogger("ConfluenceScorerTests"), 100);
+        }
+
+        private static StrategyIntent CreateIntent()
+        {
+            return new StrategyIntent(
+                "ES",
+                OrderSide.Buy,
+                OrderType.Market,
+                null,
+                8,
+                16,
+                0.8,
+                "Test",
+                new Dictionary<string, object>());
+        }
+
+        private static StrategyContext CreateContext()
+        {
+            return new StrategyContext(
+                "ES",
+                DateTime.UtcNow,
+                new Position("ES", 0, 0, 0, 0, DateTime.UtcNow),
+                new AccountInfo(100000, 100000, 0, 0, DateTime.UtcNow),
+                new MarketSession(DateTime.Today.AddHours(9.5), DateTime.Today.AddHours(16), true, "RTH"),
+                new Dictionary<string, object>());
+        }
+
+        private static BarData CreateBar()
+        {
+            return new BarData("ES", DateTime.UtcNow, 5000, 5005, 4998, 5002, 1000, TimeSpan.FromMinutes(1));
+        }
+
+        private static List<IFactorCalculator> CreateFactors()
+        {
+            var factors = new List<IFactorCalculator>();
+            factors.Add(new FixedFactorCalculator(FactorType.Setup, 0.8, 1.0));
+            factors.Add(new FixedFactorCalculator(FactorType.Trend, 0.7, 1.0));
+            factors.Add(new FixedFactorCalculator(FactorType.Volatility, 0.6, 1.0));
+            return factors;
+        }
+
+        private class FixedFactorCalculator : IFactorCalculator
+        {
+            private readonly FactorType _type;
+            private readonly double _score;
+            private readonly double _weight;
+
+            public FixedFactorCalculator(FactorType type, double score, double weight)
+            {
+                _type = type;
+                _score = score;
+                _weight = weight;
+            }
+
+            public FactorType Type
+            {
+                get { return _type; }
+            }
+
+            public ConfluenceFactor Calculate(StrategyIntent intent, StrategyContext context, BarData bar)
+            {
+                return new ConfluenceFactor(
+                    _type,
+                    "Fixed",
+                    _score,
+                    _weight,
+                    "Test factor",
+                    new Dictionary<string, object>());
+            }
+        }
+    }
+}

tests/NT8.Core.Tests/Intelligence/RegimeDetectionTests.cs

@@ -0,0 +1,275 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NT8.Core.Common.Models;
+using NT8.Core.Intelligence;
+using NT8.Core.Logging;
+
+namespace NT8.Core.Tests.Intelligence
+{
+    [TestClass]
+    public class RegimeDetectionTests
+    {
+        [TestMethod]
+        public void VolatilityDetector_ClassifiesLow()
+        {
+            var detector = CreateVolDetector();
+            var regime = detector.DetectRegime("ES", 0.5, 1.0);
+            Assert.AreEqual(VolatilityRegime.Low, regime);
+        }
+
+        [TestMethod]
+        public void VolatilityDetector_ClassifiesBelowNormal()
+        {
+            var detector = CreateVolDetector();
+            var regime = detector.DetectRegime("ES", 0.7, 1.0);
+            Assert.AreEqual(VolatilityRegime.BelowNormal, regime);
+        }
+
+        [TestMethod]
+        public void VolatilityDetector_ClassifiesNormal()
+        {
+            var detector = CreateVolDetector();
+            var regime = detector.DetectRegime("ES", 1.0, 1.0);
+            Assert.AreEqual(VolatilityRegime.Normal, regime);
+        }
+
+        [TestMethod]
+        public void VolatilityDetector_ClassifiesElevated()
+        {
+            var detector = CreateVolDetector();
+            var regime = detector.DetectRegime("ES", 1.3, 1.0);
+            Assert.AreEqual(VolatilityRegime.Elevated, regime);
+        }
+
+        [TestMethod]
+        public void VolatilityDetector_ClassifiesHigh()
+        {
+            var detector = CreateVolDetector();
+            var regime = detector.DetectRegime("ES", 1.7, 1.0);
+            Assert.AreEqual(VolatilityRegime.High, regime);
+        }
+
+        [TestMethod]
+        public void VolatilityDetector_ClassifiesExtreme()
+        {
+            var detector = CreateVolDetector();
+            var regime = detector.DetectRegime("ES", 2.2, 1.0);
+            Assert.AreEqual(VolatilityRegime.Extreme, regime);
+        }
+
+        [TestMethod]
+        public void VolatilityDetector_CalculateScore_ReturnsRatio()
+        {
+            var detector = CreateVolDetector();
+            var score = detector.CalculateVolatilityScore(1.5, 1.0);
+            Assert.AreEqual(1.5, score, 0.000001);
+        }
+
+        [TestMethod]
+        public void VolatilityDetector_TransitionHistory_TracksChanges()
+        {
+            var detector = CreateVolDetector();
+            detector.DetectRegime("NQ", 1.0, 1.0);
+            detector.DetectRegime("NQ", 2.3, 1.0);
+
+            var transitions = detector.GetTransitions("NQ");
+            Assert.IsTrue(transitions.Count >= 1);
+            Assert.AreEqual("NQ", transitions[0].Symbol);
+        }
+
+        [TestMethod]
+        public void VolatilityDetector_GetCurrentRegime_Unknown_ReturnsNormal()
+        {
+            var detector = CreateVolDetector();
+            var regime = detector.GetCurrentRegime("GC");
+            Assert.AreEqual(VolatilityRegime.Normal, regime);
+        }
+
+        [TestMethod]
+        public void TrendDetector_DetectsStrongUp()
+        {
+            var detector = CreateTrendDetector();
+            var bars = BuildUptrendBars(12, 5000.0, 2.0);
+
+            var regime = detector.DetectTrend("ES", bars, 4995.0);
+
+            Assert.IsTrue(regime == TrendRegime.StrongUp || regime == TrendRegime.WeakUp);
+        }
+
+        [TestMethod]
+        public void TrendDetector_DetectsStrongDown()
+        {
+            var detector = CreateTrendDetector();
+            var bars = BuildDowntrendBars(12, 5000.0, 2.0);
+
+            var regime = detector.DetectTrend("ES", bars, 5005.0);
+
+            Assert.IsTrue(regime == TrendRegime.StrongDown || regime == TrendRegime.WeakDown);
+        }
+
+        [TestMethod]
+        public void TrendDetector_CalculateStrength_UptrendPositive()
+        {
+            var detector = CreateTrendDetector();
+            var bars = BuildUptrendBars(10, 100.0, 1.0);
+
+            var strength = detector.CalculateTrendStrength(bars, 95.0);
+
+            Assert.IsTrue(strength > 0.0);
+        }
+
+        [TestMethod]
+        public void TrendDetector_CalculateStrength_DowntrendNegative()
+        {
+            var detector = CreateTrendDetector();
+            var bars = BuildDowntrendBars(10, 100.0, 1.0);
+
+            var strength = detector.CalculateTrendStrength(bars, 105.0);
+
+            Assert.IsTrue(strength < 0.0);
+        }
+
+        [TestMethod]
+        public void TrendDetector_IsRanging_FlatBars_True()
+        {
+            var detector = CreateTrendDetector();
+            var bars = BuildRangeBars(10, 100.0, 0.1);
+
+            var ranging = detector.IsRanging(bars, 0.2);
+
+            Assert.IsTrue(ranging);
+        }
+
+        [TestMethod]
+        public void TrendDetector_AssessTrendQuality_GoodStructure_ReturnsNotPoor()
+        {
+            var detector = CreateTrendDetector();
+            var bars = BuildUptrendBars(12, 100.0, 0.8);
+
+            var quality = detector.AssessTrendQuality(bars);
+
+            Assert.IsTrue(quality == TrendQuality.Fair || quality == TrendQuality.Good || quality == TrendQuality.Excellent);
+        }
+
+        [TestMethod]
+        public void RegimeManager_UpdateAndGetCurrentRegime_ReturnsState()
+        {
+            var manager = CreateRegimeManager();
+            var bar = CreateBar("ES", 5000, 5004, 4998, 5002, 1000);
+
+            manager.UpdateRegime("ES", bar, 5000.0, 1.0, 1.0);
+            var state = manager.GetCurrentRegime("ES");
+
+            Assert.IsNotNull(state);
+            Assert.AreEqual("ES", state.Symbol);
+        }
+
+        [TestMethod]
+        public void RegimeManager_ShouldAdjustStrategy_ExtremeVolatility_True()
+        {
+            var manager = CreateRegimeManager();
+            var bars = BuildUptrendBars(6, 5000.0, 1.0);
+
+            for (var i = 0; i < bars.Count; i++)
+            {
+                manager.UpdateRegime("ES", bars[i], 5000.0, 2.5, 1.0);
+            }
+
+            var intent = CreateIntent(OrderSide.Buy);
+            var shouldAdjust = manager.ShouldAdjustStrategy("ES", intent);
+
+            Assert.IsTrue(shouldAdjust);
+        }
+
+        [TestMethod]
+        public void RegimeManager_TransitionsRecorded_WhenRegimeChanges()
+        {
+            var manager = CreateRegimeManager();
+            var bars = BuildUptrendBars(6, 5000.0, 1.0);
+
+            for (var i = 0; i < bars.Count; i++)
+            {
+                manager.UpdateRegime("NQ", bars[i], 5000.0, 1.0, 1.0);
+            }
+
+            manager.UpdateRegime("NQ", CreateBar("NQ", 5000, 5001, 4990, 4991, 1500), 5000.0, 2.3, 1.0);
+
+            var transitions = manager.GetRecentTransitions("NQ", TimeSpan.FromHours(2));
+            Assert.IsTrue(transitions.Count >= 1);
+        }
+
+        private static VolatilityRegimeDetector CreateVolDetector()
+        {
+            return new VolatilityRegimeDetector(new BasicLogger("RegimeDetectionTests"), 50);
+        }
+
+        private static TrendRegimeDetector CreateTrendDetector()
+        {
+            return new TrendRegimeDetector(new BasicLogger("RegimeDetectionTests"));
+        }
+
+        private static RegimeManager CreateRegimeManager()
+        {
+            var logger = new BasicLogger("RegimeManagerTests");
+            var vol = new VolatilityRegimeDetector(logger, 50);
+            var trend = new TrendRegimeDetector(logger);
+            return new RegimeManager(logger, vol, trend, 200, 100);
+        }
+
+        private static List<BarData> BuildUptrendBars(int count, double start, double step)
+        {
+            var result = new List<BarData>();
+            var time = DateTime.UtcNow.AddMinutes(-count);
+            for (var i = 0; i < count; i++)
+            {
+                var close = start + (i * step);
+                result.Add(new BarData("ES", time.AddMinutes(i), close - 1.0, close + 1.0, close - 2.0, close, 1000 + i, TimeSpan.FromMinutes(1)));
+            }
+            return result;
+        }
+
+        private static List<BarData> BuildDowntrendBars(int count, double start, double step)
+        {
+            var result = new List<BarData>();
+            var time = DateTime.UtcNow.AddMinutes(-count);
+            for (var i = 0; i < count; i++)
+            {
+                var close = start - (i * step);
+                result.Add(new BarData("ES", time.AddMinutes(i), close + 1.0, close + 2.0, close - 1.0, close, 1000 + i, TimeSpan.FromMinutes(1)));
+            }
+            return result;
+        }
+
+        private static List<BarData> BuildRangeBars(int count, double center, double amplitude)
+        {
+            var result = new List<BarData>();
+            var time = DateTime.UtcNow.AddMinutes(-count);
+            for (var i = 0; i < count; i++)
+            {
+                var close = center + ((i % 2 == 0) ? amplitude : -amplitude);
+                result.Add(new BarData("ES", time.AddMinutes(i), close - 0.05, close + 0.10, close - 0.10, close, 800 + i, TimeSpan.FromMinutes(1)));
+            }
+            return result;
+        }
+
+        private static BarData CreateBar(string symbol, double open, double high, double low, double close, long volume)
+        {
+            return new BarData(symbol, DateTime.UtcNow, open, high, low, close, volume, TimeSpan.FromMinutes(1));
+        }
+
+        private static StrategyIntent CreateIntent(OrderSide side)
+        {
+            return new StrategyIntent(
+                "ES",
+                side,
+                OrderType.Market,
+                null,
+                8,
+                16,
+                0.8,
+                "Test",
+                new Dictionary<string, object>());
+        }
+    }
+}

tests/NT8.Core.Tests/Intelligence/RiskModeManagerTests.cs

@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NT8.Core.Intelligence;
+using NT8.Core.Logging;
+
+namespace NT8.Core.Tests.Intelligence
+{
+    [TestClass]
+    public class RiskModeManagerTests
+    {
+        [TestMethod]
+        public void Constructor_NullLogger_ThrowsArgumentNullException()
+        {
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                new RiskModeManager(null);
+            });
+        }
+
+        [TestMethod]
+        public void Constructor_DefaultMode_IsPCP()
+        {
+            var manager = CreateManager();
+            Assert.AreEqual(RiskMode.PCP, manager.GetCurrentMode());
+        }
+
+        [TestMethod]
+        public void GetModeConfig_ECP_ReturnsExpectedValues()
+        {
+            var manager = CreateManager();
+            var config = manager.GetModeConfig(RiskMode.ECP);
+
+            Assert.IsNotNull(config);
+            Assert.AreEqual(RiskMode.ECP, config.Mode);
+            Assert.AreEqual(1.5, config.SizeMultiplier, 0.000001);
+            Assert.AreEqual(TradeGrade.B, config.MinimumGrade);
+        }
+
+        [TestMethod]
+        public void UpdateRiskMode_StrongPerformance_TransitionsToECP()
+        {
+            var manager = CreateManager();
+
+            manager.UpdateRiskMode(600.0, 5, 0);
+
+            Assert.AreEqual(RiskMode.ECP, manager.GetCurrentMode());
+        }
+
+        [TestMethod]
+        public void UpdateRiskMode_DailyLoss_TransitionsToDCP()
+        {
+            var manager = CreateManager();
+
+            manager.UpdateRiskMode(-250.0, 0, 1);
+
+            Assert.AreEqual(RiskMode.DCP, manager.GetCurrentMode());
+        }
+
+        [TestMethod]
+        public void UpdateRiskMode_LossStreak3_TransitionsToHR()
+        {
+            var manager = CreateManager();
+
+            manager.UpdateRiskMode(0.0, 0, 3);
+
+            Assert.AreEqual(RiskMode.HR, manager.GetCurrentMode());
+        }
+
+        [TestMethod]
+        public void OverrideMode_SetsManualOverrideAndMode()
+        {
+            var manager = CreateManager();
+
+            manager.OverrideMode(RiskMode.HR, "Risk officer action");
+            var state = manager.GetState();
+
+            Assert.AreEqual(RiskMode.HR, manager.GetCurrentMode());
+            Assert.IsTrue(state.IsManualOverride);
+            Assert.AreEqual("Risk officer action", state.LastTransitionReason);
+        }
+
+        [TestMethod]
+        public void UpdateRiskMode_WhenManualOverride_DoesNotChangeMode()
+        {
+            var manager = CreateManager();
+            manager.OverrideMode(RiskMode.DCP, "Manual hold");
+
+            manager.UpdateRiskMode(1000.0, 5, 0);
+
+            Assert.AreEqual(RiskMode.DCP, manager.GetCurrentMode());
+            Assert.IsTrue(manager.GetState().IsManualOverride);
+        }
+
+        [TestMethod]
+        public void ResetToDefault_FromManualOverride_ResetsToPCP()
+        {
+            var manager = CreateManager();
+            manager.OverrideMode(RiskMode.HR, "Stop trading");
+
+            manager.ResetToDefault();
+
+            var state = manager.GetState();
+            Assert.AreEqual(RiskMode.PCP, manager.GetCurrentMode());
+            Assert.IsFalse(state.IsManualOverride);
+            Assert.AreEqual("Reset to default", state.LastTransitionReason);
+        }
+
+        [TestMethod]
+        public void ShouldTransitionMode_ExtremeVolatility_ReturnsTrue()
+        {
+            var manager = CreateManager();
+            var metrics = new PerformanceMetrics(0.0, 1, 0, 0.6, 0.8, VolatilityRegime.Extreme);
+
+            var shouldTransition = manager.ShouldTransitionMode(RiskMode.PCP, metrics);
+
+            Assert.IsTrue(shouldTransition);
+        }
+
+        [TestMethod]
+        public void ShouldTransitionMode_NoChangeConditions_ReturnsFalse()
+        {
+            var manager = CreateManager();
+            var metrics = new PerformanceMetrics(50.0, 1, 0, 0.7, 0.8, VolatilityRegime.Normal);
+
+            var shouldTransition = manager.ShouldTransitionMode(RiskMode.PCP, metrics);
+
+            Assert.IsFalse(shouldTransition);
+        }
+
+        [TestMethod]
+        public void ShouldTransitionMode_FromDCPWithRecovery_ReturnsTrue()
+        {
+            var manager = CreateManager();
+            var metrics = new PerformanceMetrics(50.0, 2, 0, 0.8, 0.9, VolatilityRegime.Normal);
+
+            var shouldTransition = manager.ShouldTransitionMode(RiskMode.DCP, metrics);
+
+            Assert.IsTrue(shouldTransition);
+        }
+
+        [TestMethod]
+        public void UpdateRiskMode_FromDCPWithRecovery_TransitionsToPCP()
+        {
+            var manager = CreateManager();
+            manager.OverrideMode(RiskMode.DCP, "Set DCP");
+            manager.ResetToDefault();
+            manager.OverrideMode(RiskMode.DCP, "Re-enter DCP");
+            manager.ResetToDefault();
+
+            manager.OverrideMode(RiskMode.DCP, "Start in DCP");
+            manager.ResetToDefault();
+            manager.OverrideMode(RiskMode.DCP, "Start in DCP again");
+            manager.ResetToDefault();
+
+            // put in DCP without manual override
+            manager.UpdateRiskMode(-300.0, 0, 1);
+            Assert.AreEqual(RiskMode.DCP, manager.GetCurrentMode());
+
+            manager.UpdateRiskMode(100.0, 2, 0);
+
+            Assert.AreEqual(RiskMode.PCP, manager.GetCurrentMode());
+        }
+
+        [TestMethod]
+        public void OverrideMode_EmptyReason_ThrowsArgumentNullException()
+        {
+            var manager = CreateManager();
+
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                manager.OverrideMode(RiskMode.HR, string.Empty);
+            });
+        }
+
+        [TestMethod]
+        public void UpdateRiskMode_NegativeStreaks_ThrowsArgumentException()
+        {
+            var manager = CreateManager();
+
+            Assert.ThrowsException<ArgumentException>(delegate
+            {
+                manager.UpdateRiskMode(0.0, -1, 0);
+            });
+
+            Assert.ThrowsException<ArgumentException>(delegate
+            {
+                manager.UpdateRiskMode(0.0, 0, -1);
+            });
+        }
+
+        private static RiskModeManager CreateManager()
+        {
+            return new RiskModeManager(new BasicLogger("RiskModeManagerTests"));
+        }
+    }
+}

tests/NT8.Core.Tests/Sizing/GradeBasedSizerTests.cs

@@ -0,0 +1,273 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NT8.Core.Common.Models;
+using NT8.Core.Intelligence;
+using NT8.Core.Logging;
+using NT8.Core.Sizing;
+
+namespace NT8.Core.Tests.Sizing
+{
+    [TestClass]
+    public class GradeBasedSizerTests
+    {
+        [TestMethod]
+        public void Constructor_NullLogger_ThrowsArgumentNullException()
+        {
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                new GradeBasedSizer(null, new GradeFilter());
+            });
+        }
+
+        [TestMethod]
+        public void Constructor_NullGradeFilter_ThrowsArgumentNullException()
+        {
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                new GradeBasedSizer(new BasicLogger("test"), null);
+            });
+        }
+
+        [TestMethod]
+        public void CombineMultipliers_MultipliesValues()
+        {
+            var sizer = CreateSizer();
+            var result = sizer.CombineMultipliers(1.25, 0.8);
+            Assert.AreEqual(1.0, result, 0.000001);
+        }
+
+        [TestMethod]
+        public void ApplyConstraints_BelowMin_ReturnsMin()
+        {
+            var sizer = CreateSizer();
+            var result = sizer.ApplyConstraints(0, 1, 10);
+            Assert.AreEqual(1, result);
+        }
+
+        [TestMethod]
+        public void ApplyConstraints_AboveMax_ReturnsMax()
+        {
+            var sizer = CreateSizer();
+            var result = sizer.ApplyConstraints(20, 1, 10);
+            Assert.AreEqual(10, result);
+        }
+
+        [TestMethod]
+        public void ApplyConstraints_WithinRange_ReturnsInput()
+        {
+            var sizer = CreateSizer();
+            var result = sizer.ApplyConstraints(5, 1, 10);
+            Assert.AreEqual(5, result);
+        }
+
+        [TestMethod]
+        public void CalculateGradeBasedSize_RejectedGrade_ReturnsZeroContracts()
+        {
+            var sizer = CreateSizer();
+            var baseSizer = new StubPositionSizer(4, 400.0, SizingMethod.FixedDollarRisk);
+
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var confluence = CreateScore(TradeGrade.C, 0.6);
+            var config = CreateSizingConfig();
+            var modeConfig = CreateModeConfig(RiskMode.DCP, 0.5, TradeGrade.A);
+
+            var result = sizer.CalculateGradeBasedSize(
+                intent,
+                context,
+                confluence,
+                RiskMode.DCP,
+                config,
+                baseSizer,
+                modeConfig);
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(0, result.Contracts);
+            Assert.IsTrue(result.Calculations.ContainsKey("rejected"));
+        }
+
+        [TestMethod]
+        public void CalculateGradeBasedSize_AcceptedGrade_AppliesMultipliers()
+        {
+            var sizer = CreateSizer();
+            var baseSizer = new StubPositionSizer(4, 400.0, SizingMethod.FixedDollarRisk);
+
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var confluence = CreateScore(TradeGrade.A, 0.85);
+            var config = CreateSizingConfig();
+            var modeConfig = CreateModeConfig(RiskMode.ECP, 1.5, TradeGrade.B);
+
+            var result = sizer.CalculateGradeBasedSize(
+                intent,
+                context,
+                confluence,
+                RiskMode.ECP,
+                config,
+                baseSizer,
+                modeConfig);
+
+            // Base contracts = 4
+            // Grade multiplier (ECP, A) = 1.25
+            // Mode multiplier = 1.5
+            // Raw = 7.5, floor => 7
+            Assert.AreEqual(7, result.Contracts);
+            Assert.IsTrue(result.Calculations.ContainsKey("combined_multiplier"));
+        }
+
+        [TestMethod]
+        public void CalculateGradeBasedSize_RespectsMaxContracts()
+        {
+            var sizer = CreateSizer();
+            var baseSizer = new StubPositionSizer(8, 800.0, SizingMethod.FixedDollarRisk);
+
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var confluence = CreateScore(TradeGrade.APlus, 0.92);
+            var config = new SizingConfig(SizingMethod.FixedDollarRisk, 1, 10, 500.0, new Dictionary<string, object>());
+            var modeConfig = CreateModeConfig(RiskMode.ECP, 1.5, TradeGrade.B);
+
+            var result = sizer.CalculateGradeBasedSize(
+                intent,
+                context,
+                confluence,
+                RiskMode.ECP,
+                config,
+                baseSizer,
+                modeConfig);
+
+            // 8 * 1.5 * 1.5 = 18 -> clamp 10
+            Assert.AreEqual(10, result.Contracts);
+        }
+
+        [TestMethod]
+        public void CalculateGradeBasedSize_RespectsMinContracts_WhenAccepted()
+        {
+            var sizer = CreateSizer();
+            var baseSizer = new StubPositionSizer(1, 100.0, SizingMethod.FixedDollarRisk);
+
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var confluence = CreateScore(TradeGrade.C, 0.61);
+            var config = new SizingConfig(SizingMethod.FixedDollarRisk, 2, 10, 500.0, new Dictionary<string, object>());
+            var modeConfig = CreateModeConfig(RiskMode.PCP, 1.0, TradeGrade.C);
+
+            var result = sizer.CalculateGradeBasedSize(
+                intent,
+                context,
+                confluence,
+                RiskMode.PCP,
+                config,
+                baseSizer,
+                modeConfig);
+
+            Assert.AreEqual(2, result.Contracts);
+        }
+
+        [TestMethod]
+        public void CalculateGradeBasedSize_NullInputs_Throw()
+        {
+            var sizer = CreateSizer();
+            var baseSizer = new StubPositionSizer(1, 100.0, SizingMethod.FixedDollarRisk);
+            var intent = CreateIntent();
+            var context = CreateContext();
+            var confluence = CreateScore(TradeGrade.A, 0.8);
+            var config = CreateSizingConfig();
+            var modeConfig = CreateModeConfig(RiskMode.PCP, 1.0, TradeGrade.C);
+
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                sizer.CalculateGradeBasedSize(null, context, confluence, RiskMode.PCP, config, baseSizer, modeConfig);
+            });
+
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                sizer.CalculateGradeBasedSize(intent, null, confluence, RiskMode.PCP, config, baseSizer, modeConfig);
+            });
+
+            Assert.ThrowsException<ArgumentNullException>(delegate
+            {
+                sizer.CalculateGradeBasedSize(intent, context, null, RiskMode.PCP, config, baseSizer, modeConfig);
+            });
+        }
+
+        private static GradeBasedSizer CreateSizer()
+        {
+            return new GradeBasedSizer(new BasicLogger("GradeBasedSizerTests"), new GradeFilter());
+        }
+
+        private static StrategyIntent CreateIntent()
+        {
+            return new StrategyIntent(
+                "ES",
+                OrderSide.Buy,
+                OrderType.Market,
+                null,
+                8,
+                16,
+                0.8,
+                "Test intent",
+                new Dictionary<string, object>());
+        }
+
+        private static StrategyContext CreateContext()
+        {
+            return new StrategyContext(
+                "ES",
+                DateTime.UtcNow,
+                new Position("ES", 0, 0, 0, 0, DateTime.UtcNow),
+                new AccountInfo(100000, 100000, 0, 0, DateTime.UtcNow),
+                new MarketSession(DateTime.Today.AddHours(9.5), DateTime.Today.AddHours(16), true, "RTH"),
+                new Dictionary<string, object>());
+        }
+
+        private static ConfluenceScore CreateScore(TradeGrade grade, double weighted)
+        {
+            var factors = new List<ConfluenceFactor>();
+            factors.Add(new ConfluenceFactor(FactorType.Setup, "Setup", weighted, 1.0, "test", new Dictionary<string, object>()));
+
+            return new ConfluenceScore(
+                weighted,
+                weighted,
+                grade,
+                factors,
+                DateTime.UtcNow,
+                new Dictionary<string, object>());
+        }
+
+        private static SizingConfig CreateSizingConfig()
+        {
+            return new SizingConfig(SizingMethod.FixedDollarRisk, 1, 10, 500.0, new Dictionary<string, object>());
+        }
+
+        private static RiskModeConfig CreateModeConfig(RiskMode mode, double sizeMultiplier, TradeGrade minGrade)
+        {
+            return new RiskModeConfig(mode, sizeMultiplier, minGrade, 1000.0, 3, false, new Dictionary<string, object>());
+        }
+
+        private class StubPositionSizer : IPositionSizer
+        {
+            private readonly int _contracts;
+            private readonly double _risk;
+            private readonly SizingMethod _method;
+
+            public StubPositionSizer(int contracts, double risk, SizingMethod method)
+            {
+                _contracts = contracts;
+                _risk = risk;
+                _method = method;
+            }
+
+            public SizingResult CalculateSize(StrategyIntent intent, StrategyContext context, SizingConfig config)
+            {
+                return new SizingResult(_contracts, _risk, _method, new Dictionary<string, object>());
+            }
+
+            public SizingMetadata GetMetadata()
+            {
+                return new SizingMetadata("Stub", "Stub sizer", new List<string>());
+            }
+        }
+    }
+}