feat: Shadow Run Design Phase — 252+ trading-day validation framework

Implements foundation for model evaluation per AGENTS.md v16.0:
- Domain models: ShadowRunCommand, ShadowRunResult, ValidationGates
- Data backfiller: OHLCV + fee schedule collection from KRX API
- Replay engine: Historical model simulation with signal/order/fill tracking
- Metrics calculator: Sharpe, Calmar, PBO, DSR, Max Drawdown, Win Rate
- Hangfire job orchestrator: Async shadow run execution (q-research queue)
- Integration tests: 4/4 passing (backfill, replay, metrics, validation)

Contract validation:
- Input: Model ID, date window, market phase filter
- Output: Immutable result with phase breakdown, gate status
- Gates: PBO ≤ 20%, DSR ≥ 95%, cost 2x positive

Architecture adherence:
- SOLID: Single responsibility (backfiller, replay, calculator separation)
- Complexity: Cyclomatic < 10 per method
- Safety: Idempotent replay via deterministic price/order fills
- Necessity: Grounded in CLAUDE.md § "Validation Gates"
- Pattern: Vertical Slice (Command → Handler → Queries)

Not included (future):
- Full 252-day rehearsal (requires market data backfill)
- Downstream inbox consumers (event delivery mechanisms)
- Phase segmentation logic (Bull/Bear/Sideways attribution)

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

src/KArtSell.Modules.ModelOperations/ShadowRun/DataBackfiller.cs

@@ -0,0 +1,170 @@
+using KArtSell.BuildingBlocks.Time;
+using Microsoft.Extensions.Logging;
+
+namespace KArtSell.Modules.ModelOperations.ShadowRun;
+
+/// <summary>
+/// Backfills historical OHLCV and FeeSchedule data for shadow run period.
+/// Data fetched from KRX API and normalized to trading-session boundaries.
+/// </summary>
+public sealed class DataBackfiller(
+    IMarketCalendarService marketCalendar,
+    IKrxDataService krxData,
+    ILogger<DataBackfiller> logger)
+{
+    public record OhlcvBar(
+        DateOnly Date,
+        string Ticker,
+        decimal Open,
+        decimal High,
+        decimal Low,
+        decimal Close,
+        long Volume);
+
+    public record FeeScheduleEntry(
+        DateOnly EffectiveDate,
+        decimal TransactionFeePercent,
+        decimal SlippagePercent);
+
+    /// <summary>
+    /// Fetch OHLCV for all tickers in portfolio across shadow run window.
+    /// </summary>
+    public async Task<IReadOnlyList<OhlcvBar>> BackfillOhlcvAsync(
+        DateOnly windowStart,
+        DateOnly windowEnd,
+        IReadOnlyList<string> tickers,
+        CancellationToken cancellationToken)
+    {
+        // Validate window against market calendar
+        var tradingSessions = await marketCalendar.GetTradingSessionsAsync(
+            windowStart, windowEnd, cancellationToken);
+
+        logger.LogInformation(
+            "Backfilling OHLCV: {TickerCount} tickers, {TradingDays} trading days ({Start:yyyy-MM-dd} to {End:yyyy-MM-dd})",
+            tickers.Count, tradingSessions.Count, windowStart, windowEnd);
+
+        var bars = new List<OhlcvBar>();
+
+        foreach (var ticker in tickers)
+        {
+            var tickerBars = await krxData.GetDailyOhlcvAsync(
+                ticker, windowStart, windowEnd, cancellationToken);
+            bars.AddRange(tickerBars);
+        }
+
+        logger.LogInformation("Backfilled {BarCount} OHLCV bars", bars.Count);
+        return bars;
+    }
+
+    /// <summary>
+    /// Fetch transaction fee schedule for window.
+    /// </summary>
+    public async Task<IReadOnlyList<FeeScheduleEntry>> BackfillFeeScheduleAsync(
+        DateOnly windowStart,
+        DateOnly windowEnd,
+        CancellationToken cancellationToken)
+    {
+        logger.LogInformation(
+            "Backfilling fee schedule ({Start:yyyy-MM-dd} to {End:yyyy-MM-dd})",
+            windowStart, windowEnd);
+
+        var schedule = await krxData.GetFeeScheduleAsync(windowStart, windowEnd, cancellationToken);
+
+        logger.LogInformation("Backfilled {ScheduleEntries} fee schedule entries", schedule.Count);
+        return schedule;
+    }
+
+    /// <summary>
+    /// Validate data completeness: no gaps, all tickers present, fee schedule continuous.
+    /// </summary>
+    public async Task<DataBackfillValidationResult> ValidateAsync(
+        IReadOnlyList<OhlcvBar> bars,
+        IReadOnlyList<FeeScheduleEntry> fees,
+        IReadOnlyList<string> expectedTickers,
+        DateOnly windowStart,
+        DateOnly windowEnd,
+        CancellationToken cancellationToken)
+    {
+        var tradingSessions = await marketCalendar.GetTradingSessionsAsync(
+            windowStart, windowEnd, cancellationToken);
+
+        var result = new DataBackfillValidationResult(
+            IsValid: true,
+            TradingDaysProcessed: 0,
+            MissingTickers: new List<string>(),
+            DataGaps: new List<string>());
+
+        // Check OHLCV completeness
+        var tickersBars = bars.GroupBy(b => b.Ticker).ToDictionary(g => g.Key, g => g.ToList());
+        var missingTickers = expectedTickers.Where(t => !tickersBars.ContainsKey(t)).ToList();
+
+        if (missingTickers.Any())
+        {
+            result = result with { MissingTickers = missingTickers };
+        }
+
+        // Check for gaps in each ticker
+        foreach (var (ticker, tickerBars) in tickersBars)
+        {
+            var tickerDates = tickerBars.Select(b => b.Date).OrderBy(d => d).ToList();
+            var sessionDates = tradingSessions.ToList();
+
+            var gaps = sessionDates.Where(s => !tickerDates.Contains(s)).ToList();
+            if (gaps.Any())
+            {
+                var updatedGaps = (result.DataGaps ?? new List<string>()).Concat(
+                    gaps.Select(g => $"{ticker}:{g:yyyy-MM-dd}")).ToList();
+                result = result with { DataGaps = updatedGaps };
+            }
+        }
+
+        // Check fee schedule continuity
+        var feesByDate = fees.GroupBy(f => f.EffectiveDate).ToDictionary(g => g.Key);
+        var feeDates = feesByDate.Keys.OrderBy(d => d).ToList();
+
+        if (!feeDates.Any())
+        {
+            result = result with { IsValid = false };
+        }
+
+        result = result with { TradingDaysProcessed = tradingSessions.Count };
+        return result;
+    }
+}
+
+public sealed record DataBackfillValidationResult(
+    bool IsValid = true,
+    int TradingDaysProcessed = 0,
+    List<string>? MissingTickers = null,
+    List<string>? DataGaps = null)
+{
+    public bool HasIssues => !IsValid || (MissingTickers?.Any() ?? false) || (DataGaps?.Any() ?? false);
+}
+
+/// <summary>
+/// Market calendar service: trading sessions, holidays, special sessions.
+/// </summary>
+public interface IMarketCalendarService
+{
+    Task<IReadOnlyList<DateOnly>> GetTradingSessionsAsync(
+        DateOnly start,
+        DateOnly end,
+        CancellationToken cancellationToken);
+}
+
+/// <summary>
+/// KRX data service: OHLCV, fee schedule.
+/// </summary>
+public interface IKrxDataService
+{
+    Task<IReadOnlyList<DataBackfiller.OhlcvBar>> GetDailyOhlcvAsync(
+        string ticker,
+        DateOnly start,
+        DateOnly endDate,
+        CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<DataBackfiller.FeeScheduleEntry>> GetFeeScheduleAsync(
+        DateOnly start,
+        DateOnly endDate,
+        CancellationToken cancellationToken);
+}