mql5/Experts/Advisors/DualEA/docs/Configuration-Reference.md

# Configuration Reference — DualEA System

**Actual input parameters from PaperEA_v2.mq5 and LiveEA.mq5**

> **IMPORTANT:** Previous versions of this document listed aspirational/planned inputs that do not exist in the code. This version documents only the actual `input` declarations found in the source files.

---

## Quick Reference: Key Differences Between EAs

| Feature | PaperEA_v2 | LiveEA |
|---------|-----------|--------|
| **NoConstraintsMode** | default `true` | default `false` |
| **Policy Reload** | Hot-reload via `policy.reload` + HTTP polling | Load on init only (restart required) |
| **Insights Rebuild** | Input exists but not implemented | Requests rebuild via `insights.reload` |
| **Signal Generation** | 23 indicator signal generators | Strategy bridge (not called from OnTick) |
| **Telemetry** | `TelemetryEnabled = true` | `TelemetryEnabled = false` |
| **Exploration Caps** | 100/100 (daily/weekly) | 100/100 (daily/weekly) |

---

## PaperEA_v2 Input Parameters

Located in: `PaperEA/PaperEA_v2.mq5`

### Basic Trading Parameters

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `LotSize` | double | 0.0 | Position size in lots (0 = use VolatilitySizer) |
| `MagicNumber` | int | 12345 | EA identification number |
| `StopLossPips_Input` | double | 150.0 | Initial SL in pips (adaptive) |
| `TakeProfitPips_Input` | double | 300.0 | Initial TP in pips (adaptive) |
| `MaxOpenPositions` | int | 0 | Max concurrent positions (0 = unlimited) |

**Trailing Stop Configuration**
```cpp
input bool     TrailEnabled = true;              // Enable trailing stops
input int      TrailType = 2;                    // 0=fixed points, 2=ATR-based
input int      TrailActivationPoints = 30;       // Profit points before trail activates
input int      TrailDistancePoints = 20;         // Distance from current price
input int      TrailStepPoints = 5;              // Minimum step for SL adjustment
input int      TrailATRPeriod = 14;              // ATR period for dynamic trailing
input double   TrailATRMultiplier = 2.0;         // ATR multiplier for trail distance
```

### Gating System Configuration

**Master Switches**
```cpp
input bool     NoConstraintsMode = true;         // Bypass many gates (circuit/memory/news still enforced)
input bool     UseInsightsGating = true;         // Enable insights-based gating
input int      GateMinTrades = 0;                // Minimum trades required in slice
input double   GateMinWinRate = 0.00;            // Minimum win rate (0 = no minimum)
input double   GateMinExpectancyR = -10.0;       // Minimum expectancy R
input double   GateMaxDrawdownR = 1000000.0;     // Maximum drawdown R
input double   GateMinProfitFactor = 0.00;       // Minimum profit factor
```

**Note:** The 8-stage gate system (`G1_SignalRinse` through `G8_FinalVerify`) described in earlier documentation was aspirational. The actual implementation uses:
- `NoConstraintsMode` to bypass non-critical gates
- `UseInsightsGating` with threshold inputs above
- `UsePolicyGating` for ML policy filtering
- Risk gates (circuit breakers, news filter, regime detection) always enforced

### Insights Gating Configuration

**Thresholds**
```cpp
input double   InsightsMinWinRate = 0.50;        // Minimum win rate to pass insights gate
input int      InsightsMinTotalTrades = 10;      // Minimum trades required in insights
input double   InsightsMinAvgR = 0.3;            // Minimum average R-multiple
input double   InsightsMinSharpe = 0.0;          // Minimum Sharpe ratio (0=disabled)
```

**Freshness & Auto-Reload**
```cpp
input bool     InsightsAutoReload = true;        // Input exists but auto-rebuild NOT IMPLEMENTED
input int      InsightsStaleHours = 48;          // Consider stale after this many hours
input int      InsightsMinSourceAdvanceHours = 48; // Min hours source files must be ahead
input int      InsightsMinIntervalHours = 24;    // Minimum interval between rebuilds
input bool     InsightsCheckOnTimer = true;      // Enable timer-based staleness checks
input int      InsightsRebuildTimeoutMs = 1800000; // Timeout for rebuild (30 min)
```

> **Note:** `InsightsAutoReload` input exists but the actual auto-rebuild logic is commented out in `CheckInsightsReload()`. Use `Scripts/InsightsRebuild.mq5` to manually rebuild insights.

### Exploration Mode Configuration

**Caps & Limits**
```cpp
input int      ExploreMaxPerSlicePerDay = 100;   // Daily exploration cap per slice (default 100)
input int      ExploreMaxPerSlice = 100;         // Weekly exploration cap per slice (default 100)
input bool     ExploreOnNoSlice = true;          // Allow exploration when no slice exists
```

> **Note:** Previous documentation listed defaults of 2/3. Actual code defaults are 100/100 for both daily and weekly caps, effectively unlimited for most practical purposes.

### Policy Gating Configuration

**Fallback Behavior**
```cpp
input bool     DefaultPolicyFallback = true;     // Enable fallback when policy missing
input bool     FallbackDemoOnly = true;          // Restrict fallback to demo accounts only
input bool     FallbackWhenNoPolicy = true;      // Fallback when policy.json not loaded
input bool     FallbackWhenSliceMissing = true;  // Fallback when specific slice missing
```

**Policy Scaling & Hot-Reload**
```cpp
input bool     UsePolicyGating = true;           // Enable policy gating (minimal: checks min_confidence only)
input string   PolicyServerUrl = "";             // HTTP endpoint for policy polling
input int      PolicyHttpPollPercent = 20;       // % chance to poll HTTP vs file
input int      HotReloadIntervalSec = 10;        // Timer interval for reload checks
```

> **Note:** PaperEA_v2 supports policy hot-reload via `policy.reload` file and HTTP polling. LiveEA loads policy on init only (restart required for updates).

### Risk Management Configuration

**Circuit Breakers**
```cpp
input bool     UseCircuitBreakers = true;        // Enable circuit breaker system
input double   CBDailyLossLimitPct_Input = 5.0;  // Max daily loss (% of starting balance)
input double   CBDrawdownLimitPct = 10.0;        // Max drawdown from peak (%)
input int      CBCooldownMinutes = 60;           // Cooldown period after breaker trips
input bool     GuardsEnabled = true;             // Enable trade guards
input double   GuardMaxSpreadPoints = 0.0;       // Max spread in points (0=disabled)
```

**News Filtering**
```cpp
input bool     UseNewsFilter = true;             // Enable news blackout filtering
input int      NewsBufferBeforeMin = 30;         // Minutes before news to stop trading
input int      NewsBufferAfterMin = 30;          // Minutes after news to resume
input int      NewsImpactMin = 2;                // Minimum impact level (1=Low, 2=Med, 3=High)
input bool     NewsUseFile = true;               // Read news from CSV file
input string   NewsFileRelPath = "DualEA\\news_blackouts.csv"; // News events CSV path
```

**Regime Detection**
```cpp
input bool     UseRegimeGate = true;             // Enable market regime detection
input string   RegimeMethod = "combined";        // ATR + ADX method
input int      RegimeATRPeriod = 14;             // ATR period for regime classification
input double   RegimeMinATRPct = 0.5;            // Low volatility threshold
input double   RegimeMaxATRPct = 2.5;            // High volatility threshold
input int      RegimeADXPeriod = 14;             // ADX period for trend strength
input double   RegimeADXTrendThreshold = 25.0;   // ADX trend threshold
input bool     ATRRegimeEnable = false;          // ATR regime filtering
input int      ATRRegimePeriod = 14;             // ATR period
input int      ATRRegimeLookback = 100;          // Lookback for percentile calc
input double   ATRMinPercentile = 0.3;           // Minimum ATR percentile
input double   ATRMaxPercentile = 0.8;           // Maximum ATR percentile
input double   ATRRegimeMinATRPct = 0.5;         // Low volatility threshold
input double   ATRRegimeMaxATRPct = 2.5;         // High volatility threshold
```

**Session Management**
```cpp
input bool     UseSessionManager = true;         // Enable session management
input int      SessionEndHour = 20;              // Session end hour
input bool     UsePromotionGate = false;         // Enable promotion window
input bool     PromoLiveOnly = false;            // Apply only on live accounts
input int      PromoStartHour = 0;               // Promotion window start
input int      PromoEndHour = 24;                // Promotion window end
```

**Correlation Management**
```cpp
input bool     UseCorrelationManager = true;     // Enable correlation-based gating
input double   MaxCorrelationLimit = 0.7;        // Max avg correlation in portfolio
input int      CorrLookbackDays = 30;            // Days for correlation calculation
```

### Strategy Selector Configuration

**Scoring & Selection**
```cpp
input bool     UseStrategySelector = true;       // Enable strategy selector
input double   SelW_PF = 1.0;                    // Weight: profit factor
input double   SelW_Exp = 1.0;                   // Weight: expectancy
input double   SelW_WR = 0.5;                    // Weight: win rate
input double   SelW_DD = 0.3;                    // Weight: drawdown
input bool     SelStrictThresholds = false;      // Use strict vs probabilistic thresholds
input bool     SelUseRecency = true;             // Weight recent performance
input int      SelRecentDays = 14;               // Recent performance lookback
input double   SelRecAlpha = 0.5;                // Recency decay factor
```

> **Note:** Previous documentation listed inputs like `SelectorEnable`, `SelectorMinScore`, `SelectorTopN` which do not exist in the code.

### Knowledge Base Configuration

**File Management**
```cpp
input string   KBBasePath = "DualEA/";           // Base path in Common Files
input bool     KBRotateFiles = true;             // Enable file rotation
input int      KBRotateSizeMB = 100;             // Rotate after N MB
input bool     KBCompressRotated = true;         // Compress rotated files
```

**Logging Options**
```cpp
input bool     KBDebugInit = false;              // Write INIT line to KB on startup
input int      KBInitIntervalSec = 60;           // Interval for INIT writes
```

> **Note:** Knowledge Base is always enabled. Previous inputs like `KBEnable`, `KBLogEvents`, `KBLogFeatures` do not exist as configurable inputs.

### Telemetry & Monitoring Configuration

**Telemetry System**
```cpp
input bool     TelemetryEnabled = true;          // Enable telemetry emission
input bool     TelemetryVerbose = false;         // Verbose telemetry logging
input int      TelemetryFlushInterval = 300;     // Flush interval in seconds
input bool     TelemetryUseCSV = false;          // Use CSV format (vs JSONL)
```

> **Note:** System Monitor and Event Bus are initialized via `ConfigManager` without individual input toggles. Previous inputs like `MonitorEnable`, `EventBusEnable` do not exist.

### Phase 5 Advanced Features

**Auto-Disable / Auto-Reenable**
```cpp
input bool     P5_AutoDisableEnable = true;      // Auto-disable underperforming strategies
input double   P5_MinPF_Input = 1.20;            // Minimum profit factor threshold
input double   P5_MinWR_Input = 0.45;            // Minimum win rate threshold
input double   P5_MinExpR = -0.05;               // Minimum expectancy R
input int      P5_AutoDisableCooldownM = 1440;   // Cooldown minutes before re-enable
input bool     P5_AutoReenable = true;           // Auto-reenable after cooldown
```

**Auto-Tune**
```cpp
input bool     P5_AutoTuneEnable = true;         // Auto-tune strategy parameters
input int      P5_AutoTuneEveryMin = 60;         // Auto-tune interval
```

**Timer Rescore**
```cpp
input bool     P5_TimerRescoreEnable = true;     // Enable periodic rescoring
input int      P5_TimerRescoreEveryMin = 60;     // Rescoring interval
```

**Correlation Pruning**
```cpp
input bool     P5_CorrPruneEnable = true;        // Enable correlation pruning
input double   P5_CorrMax = 0.80;                // Max correlation threshold
input int      P5_CorrLookbackDays = 30;         // Correlation lookback
```

**MTF Confirmation**
```cpp
input bool     P5_MTFConfirmEnable = true;       // Enable MTF confirmation
input string   P5_MTFHigherTFs = "H1,H4";        // Higher timeframe pairs
input int      P5_MTFMinAgree = 1;               // Minimum MTF confirmations
```

**Stability Gate**
```cpp
input bool     P5_StabilityGateEnable = false;   // Enable stability filtering
input int      P5_StabilityWindowDays = 14;      // Stability window
input double   P5_StabilityMaxStdR = 1.00;       // Max std dev R for stability
```

**Other**
```cpp
input bool     P5_PersistLossCounters = false;   // Persist loss counters
input bool     P5_PickBestEnable = false;        // Enable best strategy selection
input int      GateAuditMinSignals = 100;        // Min signals before audit alert
input int      GateAuditMinUptimeMin = 60;       // Min uptime before audit alert
input int      GateAuditAlertCooldownMin = 5;    // Audit alert cooldown
```

> **Note:** Previous inputs for `AdaptiveOptimizerEnable`, `PolicyUpdaterEnable`, `PositionReviewerEnable`, and `GateLearningEnable` were aspirational and do not exist in the code.

### Logging & Debug Configuration

**Debug Flags**
```cpp
input bool     DebugTrailing = false;            // Debug trailing stop operations
input bool     DebugGates = false;               // Debug gate decisions
input bool     DebugStrategies = false;          // Debug strategy signals
input bool     DebugPolicy = false;              // Debug policy loading/application
input bool     DebugInsights = false;            // Debug insights loading
input bool     DebugKB = false;                  // Debug KB writes
```

**Log Levels**
```cpp
input int      LogLevel = 2;                     // 0=None, 1=Error, 2=Warning, 3=Info, 4=Debug
input bool     LogToFile = true;                 // Enable file logging
input bool     LogToJournal = true;              // Enable MT5 Journal logging
```

---

## LiveEA Parameters

Located in: `LiveEA/LiveEA.mq5`

> **IMPORTANT:** LiveEA does NOT inherit PaperEA parameters. It has its own independent input set shown below.

### Core Settings

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `MagicNumber` | long | 123456 | EA identification number |
| `Verbosity` | int | 1 | 0=errors, 1=warn, 2=info, 3=debug |
| `TelemetryEnabled` | bool | **false** | Enable telemetry emission |
| `NoConstraintsMode` | bool | **false** | Shadow-gate only, do not block |

### Telemetry

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `TelemetryExperiment` | string | "live" | Experiment name for telemetry |
| `TelemetryBufferMax` | int | 1000 | Max events before flush |

### Risk Management

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `SpreadMaxPoints` | double | 0.0 | Max spread (0=disabled) |
| `SessionStartHour` | int | 0 | Trading session start |
| `SessionMaxTrades` | int | 0 | Max trades per session |
| `MaxDailyLossPct` | double | 0.0 | Max daily loss % (0=disabled) |
| `MaxDrawdownPct` | double | 0.0 | Max drawdown % (0=disabled) |
| `MinMarginLevel` | double | 0.0 | Min margin % (0=disabled) |
| `ConsecutiveLossLimit` | int | 0 | Max consecutive losses |

### Insights Gating (same threshold names as PaperEA)

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `UseInsightsGating` | bool | true | Enable insights gating |
| `GateMinTrades` | int | 0 | Min trades in slice |
| `GateMinWinRate` | double | 0.00 | Min win rate |
| `GateMinExpectancyR` | double | -10.0 | Min expectancy R |
| `GateMaxDrawdownR` | double | 1000000.0 | Max drawdown R |
| `GateMinProfitFactor` | double | 0.00 | Min profit factor |

### Exploration

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `ExploreOnNoSlice` | bool | true | Allow exploration when no slice |
| `ExploreMaxPerSlice` | int | **100** | Weekly cap |
| `ExploreMaxPerSlicePerDay` | int | **100** | Daily cap |

### Policy Gating

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `UsePolicyGating` | bool | true | Enable policy gating |
| `DefaultPolicyFallback` | bool | true | Allow neutral when slice missing |
| `FallbackDemoOnly` | bool | true | Restrict fallback to demo |
| `FallbackWhenNoPolicy` | bool | true | Allow when policy absent |

> **Note:** LiveEA loads policy on `OnInit()` only. Restart required for policy updates (no hot-reload).

### Auto-Reload Controls

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `InsightsAutoReload` | bool | true | Request rebuild when stale |
| `InsightsLiveFreshMinutes` | int | 10 | Consider fresh if < N min old |
| `InsightsReadyPollSec` | int | 5 | Poll frequency for ready signal |

### News / Promotion / Regime

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `UseNewsFilter` | bool | false | Block around news windows |
| `NewsBufferBeforeMin` | int | 30 | Minutes before event |
| `NewsBufferAfterMin` | int | 30 | Minutes after event |
| `NewsImpactMin` | int | 2 | Min impact level |
| `NewsUseFile` | bool | true | Read from CSV |
| `NewsFileRelPath` | string | "DualEA\\news_blackouts.csv" | CSV path |
| `UsePromotionGate` | bool | false | Allow only in windows |
| `PromoLiveOnly` | bool | false | Apply only on live |
| `PromoStartHour` | int | 0 | Window start |
| `PromoEndHour` | int | 24 | Window end |
| `UseRegimeGate` | bool | false | Filter by volatility |
| `RegimeATRPeriod` | int | 14 | ATR period |
| `RegimeMinATRPct` | double | 0.0 | 0=disabled |
| `RegimeMaxATRPct` | double | 1000.0 | 1000=disabled |
| `CircuitCooldownSec` | int | 0 | Cooldown (0=disabled) |

### Session & Correlation

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `UseSessionManager` | bool | true | Enable session controls |
| `SessionEndHour` | int | 20 | Session end hour |
| `MaxTradesPerSession` | int | 10 | Max trades |
| `UseCorrelationManager` | bool | true | Enable correlation checks |
| `MaxCorrelationLimit` | double | 0.7 | Max correlation |
| `CorrLookbackDays` | int | 30 | Lookback period |
| `P5_CorrMax` | double | 1.0 | 1.0=no pruning |
| `P5_CorrLookbackDays` | int | 5 | Lookback if PM unavailable |

### Position & Volatility

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `PMMaxOpenPositions` | int | 10 | Max open positions |
| `UsePositionManager` | bool | false | Enable PositionManager |
| `UseVolatilitySizer` | bool | false | ATR-based sizing |
| `VolSizerATRPeriod` | int | 14 | ATR period |
| `VolSizerBaseATRPct` | double | 1.0 | Base ATR % |
| `VolSizerMinMult` | double | 0.1 | Min lot multiplier |

---

## Configuration Patterns

### Pattern 1: Maximum Data Collection (PaperEA)

For initial data gathering phase:

```cpp
input bool     NoConstraintsMode = true;         // Bypass non-critical gates
input int      MaxOpenPositions = 0;             // Unlimited positions
input bool     UseInsightsGating = false;        // Disable insights gating
input int      ExploreMaxPerSlicePerDay = 100;   // High exploration cap
input int      ExploreMaxPerSlice = 100;         // High weekly cap

// Still collect data
input bool     TelemetryEnabled = true;
input bool     TelemetryVerbose = true;
```

### Pattern 2: Cautious Demo Trading

For demo trading with realistic constraints:

```cpp
input bool     NoConstraintsMode = false;        // Enable gates
input int      MaxOpenPositions = 5;             // Reasonable limit
input bool     UseInsightsGating = true;
input double   GateMinWinRate = 0.50;
input int      GateMinTrades = 10;
input int      ExploreMaxPerSlicePerDay = 10;
input int      ExploreMaxPerSlice = 20;

// Conservative risk
input double   CBDailyLossLimitPct_Input = 3.0;
```

### Pattern 3: Live Trading (Conservative)

For initial live deployment (using LiveEA):

```cpp
// LiveEA inputs
input bool     NoConstraintsMode = false;        // All gates active
input int      PMMaxOpenPositions = 3;           // Very limited
input bool     UseInsightsGating = true;
input double   GateMinWinRate = 0.55;            // Stricter than paper
input int      GateMinTrades = 30;               // More data required
input bool     UsePolicyGating = true;

// Strict risk controls
input double   MaxDailyLossPct = 2.0;
input double   MaxDrawdownPct = 10.0;
input double   MinMarginLevel = 200.0;
```

### Pattern 4: ML Training Focus

Optimize for ML training data quality:

```cpp
input bool     NoConstraintsMode = true;         // Max coverage
input bool     TelemetryEnabled = true;
input bool     TelemetryVerbose = true;          // Capture all details

// Diverse strategy exposure
input bool     UseStrategySelector = true;

// Policy fallback for coverage
input bool     UsePolicyGating = true;
input bool     DefaultPolicyFallback = true;
input bool     FallbackDemoOnly = false;         // Allow everywhere for data
```

---

## Gate Configuration

### Actual Gate Implementation

The DualEA system uses a simplified gate architecture compared to the aspirational 8-stage pipeline documented earlier:

**Always-Enforced Gates (not bypassed by NoConstraintsMode):**
- Circuit breaker checks (`UseCircuitBreakers`)
- Memory limit validation
- News filter (`UseNewsFilter`)

**Optional Gates (bypassed when `NoConstraintsMode=true`):**
- Insights gating (`UseInsightsGating` with threshold inputs)
- Policy gating (`UsePolicyGating`)
- Session management (`UseSessionManager`)
- Correlation management (`UseCorrelationManager`)
- Regime detection (`UseRegimeGate`)

### Shadow Mode for Testing

Test gate decisions without blocking trades:

```cpp
input bool     NoConstraintsMode = true;         // Enable shadow mode
input bool     TelemetryVerbose = true;          // Capture shadow decisions

// Gates still evaluate but don't block
// Check telemetry for shadow gating events
```

---

## Best Practices

### 1. Start with NoConstraintsMode

Begin with unrestricted data collection:
- Set `NoConstraintsMode=true`
- Run for 2-4 weeks across multiple symbols/timeframes
- Generate comprehensive insights.json

### 2. Gradually Enable Gates

After data collection:
- Set `NoConstraintsMode=false`
- Enable gates one by one
- Monitor impact on trade count and quality

### 3. Use Exploration Wisely

Balance exploration vs exploitation:
- Start with higher caps (5/10) in paper
- Reduce caps as insights mature
- In live, use minimal caps (1/2)

### 4. Test in Strategy Tester First

Before live deployment:
- Run backtests with realistic spread/slippage
- Validate gate behavior with actual constraints
- Check exploration counter persistence

### 5. Monitor Health Scores

Track SystemMonitor health:
- Aim for >80 health score
- Investigate if dropping below 70
- Check gate success rates individually

### 6. Policy Fallback Strategy

For production live trading:
- Set `FallbackDemoOnly=true` initially
- Only disable after validating policy coverage
- Keep `DefaultPolicyFallback=true` as safety net

### 7. Risk Ladder Approach

Gradually increase risk exposure:
1. Start: 0.5% risk per trade, 2% daily loss cap
2. After 50 trades: 1.0% risk, 3% daily cap
3. After 200 trades: 1.5% risk, 5% daily cap
4. Review and adjust based on performance

---

## Configuration Checklist

### Before Going Live

- [ ] `NoConstraintsMode=false` (gates active)
- [ ] Insights gating thresholds validated
- [ ] Policy loaded and coverage checked
- [ ] Exploration caps set conservatively (1-2)
- [ ] Risk limits appropriate for account size
- [ ] Circuit breakers configured
- [ ] News calendar updated
- [ ] Position Manager tested
- [ ] Telemetry and logging working
- [ ] Strategy Tester validation completed
- [ ] Demo account forward test successful (minimum 2 weeks)

---

## P0-P5 Advanced Hardening Inputs

**Location**: `Include/PaperEA_v2_P0P5_Integration.mqh`

All P0-P5 features can be enabled/disabled via input parameters for gradual rollout.

### P0 - Production Risk Controls
```cpp
input bool     InpEnableNuclearRiskEngine = true;         // Enable VaR/Kelly/CVaR risk engine
input bool     InpEnableSQLiteKB = true;                  // Enable SQLite parallel KB
input int      InpSQLiteMigrationDays = 30;               // CSV migration period
input bool     InpEnableShadowLogging = true;             // Atomic CSV writes with checksums
input double   InpMaxPortfolioRiskPct = 15.0;             // Max portfolio risk %
input double   InpMaxCorrelationForPruning = 0.70;        // Correlation threshold for strategy pruning
```

### P1 - Architectural Hardening
```cpp
input bool     InpEnableFeatureCache = true;                // Pre-warmed indicator handles
input bool     InpEnableSystemMonitor = true;               // CPU/memory monitoring
input bool     InpEnableVolatilityExits = true;               // Trailing volatility exits
input int      InpFeatureCacheSize = 100;                 // Cache size per indicator
```

### P2 - Intelligence Enhancements
```cpp
input bool     InpEnableConceptDriftDetection = true;      // Auto-adjust gate thresholds
input bool     InpEnableAutoDriftAdjustment = true;         // Welford's algorithm adjustment
input double   InpDriftZScoreThreshold = 2.5;              // Drift detection threshold
input bool     InpEnableAutoPromotionSystem = true;        // Paper to Live promotion
input bool     InpEnableShadowTradingBridge = true;         // Parallel demo execution
input bool     InpEnableMTFConfirmationGate = true;          // Multi-timeframe confirmation
input bool     InpEnableCorrelationPruner = true;            // Correlation-aware pruning
input int      InpMTFConfirmationTimeframes = 2;             // Number of TF confirmations required
```

### P3 - Performance Optimizations
```cpp
input bool     InpEnableCPUBudgeting = true;                // CPU fail-fast processing
input int      InpCPUBudgetMsPerTick = 10;                  // Max CPU ms per tick
input bool     InpEnableIndicatorCache = true;              // Pre-warm indicator handles
input bool     InpEnableRingBuffers = true;                 // Lock-free logging
input bool     InpEnableBatchTelemetry = true;              // Batched I/O writes
input int      InpRingBufferSize = 8192;                    // Ring buffer capacity
input int      InpTelemetryBatchSize = 100;                   // Batch write size
input bool     InpEnableTimerStrategyScanner = true;           // Timer-based scanning
input int      InpStrategyScanIntervalSec = 60;              // Scan interval
```

### P4 - Strategic Evolution
```cpp
input bool     InpEnableGrpcMLBridge = false;               // gRPC ML inference (disabled by default)
input string   InpGrpcServerAddress = "localhost:50051";   // gRPC server
input bool     InpEnableAdversarialFuzzer = false;          // Jailbreak testing (debug only)
input bool     InpEnableFeatureDriftDetector = true;        // Distribution shift detection
```

### Cross-Chart Coordination
```cpp
input bool     InpEnableSymbolCoordinator = false;          // Redis coordination (disabled by default)
input string   InpRedisServerAddress = "localhost:6379";   // Redis server
input int      InpMaxPositionsPerSymbol = 5;                // Per-symbol position cap
```

**Key Design Decisions**:
- Risk gates (G1, G4, G7, G8) are never skipped under CPU pressure
- Multi-symbol management remains chart-per-symbol with Redis coordination
- SQLite runs parallel to CSV for 30-day migration period
- gRPC ML Bridge disabled by default (local ONNX preferred)
- Redis coordination disabled by default (single-chart mode)

---

**See Also:**
- [Execution-Pipeline.md](Execution-Pipeline.md) - Detailed execution flow
- [Observability-Guide.md](Observability-Guide.md) - Monitoring and telemetry
- [Policy-Exploration-Guide.md](Policy-Exploration-Guide.md) - Policy and exploration details