feat(collection): wire KIS collection end-to-end, add price-history pipeline (WBS QE-M0/M1/M2)

Critical re-review of the QuantEngine WBS evidence system found several regressions of the "no fake gates" discipline established by M0, plus a still-unwired M1 collection path. This closes 10 more WBS tasks (QE-M1-01..06, QE-M2-01/02/04/05/06 — see spec/60_quant_engine_wbs.yaml) with real, gate-verified evidence (18/34 total). M1 — real KIS data now lands in PostgreSQL end-to-end: - SchedulerService: load ticker universe from GatherTradingData.json instead of a hardcoded array; fix a Hangfire scoped-service resolution bug. - KisDataCollectionOrchestrator: restore logging on the lineage-event write path (was a bare `catch {}` swallowing all failures silently); persist daily OHLCV bars into quantengine.price_history_daily per run. - Verified live: POST /api/collection/run -> Hangfire -> orchestrator -> KIS mock API -> PostgreSQL, with Playwright DOM/API parity evidence. M2 — historical price-history pipeline: - CollectionRepository: SavePriceHistoryDailyAsync (idempotent upsert), GetPriceHistorySummaryAsync (per-ticker aggregation) + a new DateOnlyTypeHandler registered globally, since Dapper has no built-in System.DateOnly support in either direction (write threw NotSupportedException, read threw a constructor-mismatch InvalidOperationException — found by exercising both paths live). - tools/validate_price_history_integrity_v1.py: gap-freeness (vs KIS trading calendar) + price-sanity gate over collected history. - Admin Collection page: new "히스토리 현황" summary table + GET /api/collection/history-summary, with Playwright evidence. Governance/gate fixes: - validate_market_time_series_schema_v1.py mislabeled its own output "runtime_database_query": "DATA_GATED" despite never opening a DB connection (pure file/regex check) — relabeled "check_scope": "STATIC_STRUCTURAL_ONLY" and wired the node into the release DAG so it isn't only reachable from ci.yml, matching every other validator. Live-data authority for the same claim stays with QE-M2-01's pg_query gate (spec/60), documented in spec/64. - Fixed a WBS log_pattern check (QE-M1-06) that couldn't match its own multi-line target; loosened two depends_on edges (QE-M1-05/06, QE-M2-04/05) that encoded "needs X verified" when the real requirement was only "needs X's code merged." - Discovered and fixed admin-pages.spec.ts logging in with the wrong seeded password (admin/admin instead of admin/quant123!, per CLAUDE.md) — every test in that suite had been silently failing at the login step. Deferred: QE-M2-03 (2-year backfill) — the KIS mock/VTS token endpoint started returning 403 after the first successful call this session; looks like a token-issuance rate limit or credential issue on KIS's side, not a code defect. Backfilling at scale right now would just generate more 403s, so left QE-M2-03 PENDING pending KIS account/console verification. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-07-12 21:07:53 +09:00
parent f9a0ba3690
commit 5589a0432b
25 changed files with 3903 additions and 77 deletions
@@ -99,6 +99,29 @@ public class KisDataCollectionOrchestrator : ICollectionOrchestrator
                        CapturedAt: DataNormalizationHelper.KstNowIso()
                    ));

+                    // Persist daily OHLCV bars
+                    try
+                    {
+                        var today = DateTime.UtcNow.AddHours(9).ToString("yyyyMMdd");
+                        var chartResult = await _kisApiClient.GetDailyItemChartPriceAsync(ticker, today, today, "D", account);
+                        if (chartResult.TryGetValue("output2", out var output2Obj) && output2Obj is JsonElement output2Elem && output2Elem.ValueKind == JsonValueKind.Array)
+                        {
+                            foreach (var barElement in output2Elem.EnumerateArray())
+                            {
+                                if (!TryParseOhlcvBar(barElement, ticker, out var priceRecord))
+                                {
+                                    _logger.LogWarning("Skipped invalid OHLCV bar for {Ticker}: constraints not satisfied", ticker);
+                                    continue;
+                                }
+                                await _repository.SavePriceHistoryDailyAsync(priceRecord);
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogWarning(ex, "Failed to persist price history for {Ticker} (run {RunId})", ticker, runId);
+                    }
+
                    // Track source
                    if (!sourceCounts.ContainsKey(sourceName))
                        sourceCounts[sourceName] = 0;
@@ -185,6 +208,74 @@ public class KisDataCollectionOrchestrator : ICollectionOrchestrator
        }
    }

+    private static bool TryParseOhlcvBar(JsonElement barElement, string ticker, out PriceHistoryDailyRecord priceRecord)
+    {
+        priceRecord = null!;
+
+        try
+        {
+            if (barElement.ValueKind != JsonValueKind.Object)
+                return false;
+
+            var dateStr = GetJsonElementProperty(barElement, "stck_bsop_date");
+            var openStr = GetJsonElementProperty(barElement, "stck_oprc");
+            var highStr = GetJsonElementProperty(barElement, "stck_hgpr");
+            var lowStr = GetJsonElementProperty(barElement, "stck_lwpr");
+            var closeStr = GetJsonElementProperty(barElement, "stck_clpr");
+            var volumeStr = GetJsonElementProperty(barElement, "acml_vol");
+
+            if (string.IsNullOrEmpty(dateStr) || string.IsNullOrEmpty(openStr) ||
+                string.IsNullOrEmpty(highStr) || string.IsNullOrEmpty(lowStr) ||
+                string.IsNullOrEmpty(closeStr) || string.IsNullOrEmpty(volumeStr))
+                return false;
+
+            if (!DateOnly.TryParseExact(dateStr, "yyyyMMdd", null, System.Globalization.DateTimeStyles.None, out var tradeDate))
+                return false;
+
+            if (!decimal.TryParse(openStr.Replace(",", ""), out var open) ||
+                !decimal.TryParse(highStr.Replace(",", ""), out var high) ||
+                !decimal.TryParse(lowStr.Replace(",", ""), out var low) ||
+                !decimal.TryParse(closeStr.Replace(",", ""), out var close) ||
+                !long.TryParse(volumeStr.Replace(",", ""), out var volume))
+                return false;
+
+            if (volume < 0)
+                return false;
+
+            if (high < low || high < open || high < close || low > open || low > close)
+                return false;
+
+            priceRecord = new PriceHistoryDailyRecord(
+                Ticker: ticker,
+                TradeDate: tradeDate,
+                Open: open,
+                High: high,
+                Low: low,
+                Close: close,
+                Volume: volume,
+                Source: "kis_open_api"
+            );
+
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static string? GetJsonElementProperty(JsonElement element, string propertyName)
+    {
+        if (element.TryGetProperty(propertyName, out var prop))
+        {
+            if (prop.ValueKind == JsonValueKind.String)
+                return prop.GetString();
+            else if (prop.ValueKind == JsonValueKind.Number)
+                return prop.GetRawText();
+        }
+        return null;
+    }
+
    private static string GetOutputPath()
    {
        var baseDir = AppContext.BaseDirectory;
@@ -222,7 +313,7 @@ public class KisDataCollectionOrchestrator : ICollectionOrchestrator
        return false;
    }

-    private static void LogLineageEvent(string runId, string status, int successCount, int errorCount)
+    private void LogLineageEvent(string runId, string status, int successCount, int errorCount)
    {
        try
        {
@@ -259,7 +350,10 @@ public class KisDataCollectionOrchestrator : ICollectionOrchestrator
                File.AppendAllText(lineagePath, JsonSerializer.Serialize(ev) + "\n");
            }
        }
-        catch { /* Robust fallback */ }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to write lineage event for run {RunId}", runId);
+        }
    }
 }

@@ -0,0 +1,393 @@
+using Xunit;
+using Moq;
+using System.Reflection;
+using System.Text.Json;
+using Microsoft.Extensions.Logging;
+using QuantEngine.Core.Interfaces;
+using QuantEngine.Application.Services;
+
+namespace QuantEngine.Core.Tests;
+
+public class KisDataCollectionOrchestratorTests
+{
+    private readonly Mock<IKisApiClient> _kisApiClientMock;
+    private readonly Mock<ICollectionRepository> _repositoryMock;
+    private readonly Mock<ILogger<KisDataCollectionOrchestrator>> _loggerMock;
+    private readonly PriceDataNormalizer _normalizer;
+    private readonly SourcePriorityResolver _priorityResolver;
+    private readonly KisDataCollectionOrchestrator _orchestrator;
+
+    public KisDataCollectionOrchestratorTests()
+    {
+        _kisApiClientMock = new Mock<IKisApiClient>();
+        _repositoryMock = new Mock<ICollectionRepository>();
+        _loggerMock = new Mock<ILogger<KisDataCollectionOrchestrator>>();
+        _priorityResolver = new SourcePriorityResolver();
+        _normalizer = new PriceDataNormalizer(_priorityResolver);
+
+        _orchestrator = new KisDataCollectionOrchestrator(
+            _kisApiClientMock.Object,
+            _repositoryMock.Object,
+            _normalizer,
+            _priorityResolver,
+            _loggerMock.Object
+        );
+    }
+
+    [Fact]
+    public async Task RunCollectionAsync_WithCachedSnapshot_ShouldNotCallKisApiClient()
+    {
+        var runId = "test-run-001";
+        var ticker = "005930";
+        var account = "mock";
+        var todayPrefix = DateTime.UtcNow.AddHours(9).ToString("yyyy-MM-dd");
+
+        var cachedSnapshot = new CollectionSnapshotRecord(
+            RunId: "prev-run",
+            DatasetName: "data_feed",
+            Ticker: ticker,
+            SourceName: "kis_open_api",
+            PayloadJson: """{"Ticker":"005930","current_price":50000}""",
+            CapturedAt: $"{todayPrefix}T14:30:00"
+        );
+
+        _repositoryMock
+            .Setup(r => r.GetLatestSnapshotsForTickerAsync(ticker, It.IsAny<int>()))
+            .ReturnsAsync(new List<CollectionSnapshotRecord> { cachedSnapshot });
+
+        _repositoryMock
+            .Setup(r => r.SaveSnapshotAsync(It.IsAny<CollectionSnapshotRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SavePriceHistoryDailyAsync(It.IsAny<PriceHistoryDailyRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SaveRunAsync(It.IsAny<CollectionRunRecord>()))
+            .Returns(Task.CompletedTask);
+
+        var result = await _orchestrator.RunCollectionAsync(runId, account, new List<string> { ticker });
+
+        Assert.NotNull(result);
+        Assert.Equal("COMPLETED", result.Status);
+        Assert.Equal(1, result.SuccessCount);
+
+        _kisApiClientMock.Verify(
+            k => k.GetCurrentPriceAsync(It.IsAny<string>(), It.IsAny<string>()),
+            Times.Never,
+            "IsMarketClosed should return true and cached snapshot should be used, so KIS API should not be called"
+        );
+
+        _repositoryMock.Verify(
+            r => r.SaveSnapshotAsync(It.Is<CollectionSnapshotRecord>(s =>
+                s.SourceName.Contains("(Cached)"))),
+            Times.Once,
+            "Cached snapshot source name should include '(Cached)' suffix"
+        );
+    }
+
+    [Fact]
+    public async Task RunCollectionAsync_WithoutCachedSnapshot_ShouldCallKisApiClient()
+    {
+        var runId = "test-run-002";
+        var ticker = "005930";
+        var account = "mock";
+
+        _repositoryMock
+            .Setup(r => r.GetLatestSnapshotsForTickerAsync(ticker, It.IsAny<int>()))
+            .ReturnsAsync(new List<CollectionSnapshotRecord>());
+
+        _kisApiClientMock
+            .Setup(k => k.GetCurrentPriceAsync(ticker, account))
+            .ReturnsAsync(new Dictionary<string, object>
+            {
+                { "Ticker", ticker },
+                { "current_price", 50000 },
+                { "open", 49900 }
+            });
+
+        _kisApiClientMock
+            .Setup(k => k.GetDailyItemChartPriceAsync(ticker, It.IsAny<string>(), It.IsAny<string>(), "D", account))
+            .ReturnsAsync(new Dictionary<string, object>());
+
+        _repositoryMock
+            .Setup(r => r.SaveSnapshotAsync(It.IsAny<CollectionSnapshotRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SavePriceHistoryDailyAsync(It.IsAny<PriceHistoryDailyRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SaveRunAsync(It.IsAny<CollectionRunRecord>()))
+            .Returns(Task.CompletedTask);
+
+        var result = await _orchestrator.RunCollectionAsync(runId, account, new List<string> { ticker });
+
+        Assert.NotNull(result);
+        Assert.Equal("COMPLETED", result.Status);
+        Assert.Equal(1, result.SuccessCount);
+
+        _kisApiClientMock.Verify(
+            k => k.GetCurrentPriceAsync(ticker, account),
+            Times.Once,
+            "No cached snapshot exists, so KIS API should be called"
+        );
+    }
+
+    [Fact]
+    public async Task RunCollectionAsync_WithPriorDaySnapshot_ShouldCallKisApiClient()
+    {
+        var runId = "test-run-003";
+        var ticker = "005930";
+        var account = "mock";
+        var priorDay = DateTime.UtcNow.AddHours(9).AddDays(-1).ToString("yyyy-MM-dd");
+
+        var priorDaySnapshot = new CollectionSnapshotRecord(
+            RunId: "prev-run",
+            DatasetName: "data_feed",
+            Ticker: ticker,
+            SourceName: "kis_open_api",
+            PayloadJson: """{"Ticker":"005930","current_price":49000}""",
+            CapturedAt: $"{priorDay}T14:30:00"
+        );
+
+        _repositoryMock
+            .Setup(r => r.GetLatestSnapshotsForTickerAsync(ticker, It.IsAny<int>()))
+            .ReturnsAsync(new List<CollectionSnapshotRecord> { priorDaySnapshot });
+
+        _kisApiClientMock
+            .Setup(k => k.GetCurrentPriceAsync(ticker, account))
+            .ReturnsAsync(new Dictionary<string, object>
+            {
+                { "Ticker", ticker },
+                { "current_price", 50100 }
+            });
+
+        _kisApiClientMock
+            .Setup(k => k.GetDailyItemChartPriceAsync(ticker, It.IsAny<string>(), It.IsAny<string>(), "D", account))
+            .ReturnsAsync(new Dictionary<string, object>());
+
+        _repositoryMock
+            .Setup(r => r.SaveSnapshotAsync(It.IsAny<CollectionSnapshotRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SavePriceHistoryDailyAsync(It.IsAny<PriceHistoryDailyRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SaveRunAsync(It.IsAny<CollectionRunRecord>()))
+            .Returns(Task.CompletedTask);
+
+        var result = await _orchestrator.RunCollectionAsync(runId, account, new List<string> { ticker });
+
+        Assert.NotNull(result);
+        Assert.Equal("COMPLETED", result.Status);
+        Assert.Equal(1, result.SuccessCount);
+
+        _kisApiClientMock.Verify(
+            k => k.GetCurrentPriceAsync(ticker, account),
+            Times.Once,
+            "Snapshot is from prior day, not today, so KIS API should be called"
+        );
+    }
+
+    [Fact]
+    public async Task RunCollectionAsync_ShouldCompleteEvenIfLineageWriteFails()
+    {
+        var runId = "test-run-004";
+        var ticker = "005930";
+        var account = "mock";
+
+        _repositoryMock
+            .Setup(r => r.GetLatestSnapshotsForTickerAsync(ticker, It.IsAny<int>()))
+            .ReturnsAsync(new List<CollectionSnapshotRecord>());
+
+        _kisApiClientMock
+            .Setup(k => k.GetCurrentPriceAsync(ticker, account))
+            .ReturnsAsync(new Dictionary<string, object>
+            {
+                { "Ticker", ticker },
+                { "current_price", 50000 }
+            });
+
+        _kisApiClientMock
+            .Setup(k => k.GetDailyItemChartPriceAsync(ticker, It.IsAny<string>(), It.IsAny<string>(), "D", account))
+            .ReturnsAsync(new Dictionary<string, object>());
+
+        _repositoryMock
+            .Setup(r => r.SaveSnapshotAsync(It.IsAny<CollectionSnapshotRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SavePriceHistoryDailyAsync(It.IsAny<PriceHistoryDailyRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SaveRunAsync(It.IsAny<CollectionRunRecord>()))
+            .Returns(Task.CompletedTask);
+
+        var result = await _orchestrator.RunCollectionAsync(runId, account, new List<string> { ticker });
+
+        Assert.NotNull(result);
+        Assert.Equal("COMPLETED", result.Status);
+        Assert.Equal(1, result.SuccessCount);
+
+        _loggerMock.Verify(
+            l => l.Log(
+                LogLevel.Warning,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) =>
+                    v.ToString()!.Contains("Failed to write lineage event") ||
+                    v.ToString()!.Contains("lineage")),
+                It.IsAny<Exception>(),
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.Never,
+            "Lineage write should succeed in normal case (no directory permission issues)"
+        );
+    }
+
+    [Fact]
+    public async Task RunCollectionAsync_WithMultipleTickers_ShouldHandleSuccessAndErrors()
+    {
+        var runId = "test-run-005";
+        var account = "mock";
+        var tickers = new List<string> { "005930", "000660" };
+
+        _repositoryMock
+            .Setup(r => r.GetLatestSnapshotsForTickerAsync(It.IsAny<string>(), It.IsAny<int>()))
+            .ReturnsAsync(new List<CollectionSnapshotRecord>());
+
+        _kisApiClientMock
+            .Setup(k => k.GetCurrentPriceAsync("005930", account))
+            .ReturnsAsync(new Dictionary<string, object>
+            {
+                { "Ticker", "005930" },
+                { "current_price", 50000 }
+            });
+
+        _kisApiClientMock
+            .Setup(k => k.GetCurrentPriceAsync("000660", account))
+            .ReturnsAsync(new Dictionary<string, object>
+            {
+                { "Ticker", "000660" },
+                { "current_price", 100000 }
+            });
+
+        _kisApiClientMock
+            .Setup(k => k.GetDailyItemChartPriceAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), "D", account))
+            .ReturnsAsync(new Dictionary<string, object>());
+
+        var callCount = 0;
+        _repositoryMock
+            .Setup(r => r.SaveSnapshotAsync(It.IsAny<CollectionSnapshotRecord>()))
+            .Returns((CollectionSnapshotRecord snapshot) =>
+            {
+                callCount++;
+                if (callCount == 2 && snapshot.Ticker == "000660")
+                    throw new Exception("Storage Error");
+                return Task.CompletedTask;
+            });
+
+        _repositoryMock
+            .Setup(r => r.SavePriceHistoryDailyAsync(It.IsAny<PriceHistoryDailyRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SaveErrorAsync(It.IsAny<CollectionErrorRecord>()))
+            .Returns(Task.CompletedTask);
+
+        _repositoryMock
+            .Setup(r => r.SaveRunAsync(It.IsAny<CollectionRunRecord>()))
+            .Returns(Task.CompletedTask);
+
+        var result = await _orchestrator.RunCollectionAsync(runId, account, tickers);
+
+        Assert.NotNull(result);
+        Assert.Equal("COMPLETED_WITH_ERRORS", result.Status);
+        Assert.Equal(1, result.SuccessCount);
+        Assert.Equal(1, result.ErrorCount);
+
+        _repositoryMock.Verify(
+            r => r.SaveErrorAsync(It.Is<CollectionErrorRecord>(e =>
+                e.Ticker == "000660" && e.ErrorMessage == "Storage Error")),
+            Times.Once
+        );
+    }
+
+    [Fact]
+    public void TryParseOhlcvBar_WithValidBar_ShouldReturnRecord()
+    {
+        var method = typeof(KisDataCollectionOrchestrator).GetMethod(
+            "TryParseOhlcvBar",
+            BindingFlags.NonPublic | BindingFlags.Static);
+
+        Assert.NotNull(method);
+
+        using var document = JsonDocument.Parse("""
+        {
+          "stck_bsop_date": "20260711",
+          "stck_oprc": "1000",
+          "stck_hgpr": "1100",
+          "stck_lwpr": "900",
+          "stck_clpr": "1050",
+          "acml_vol": "12345"
+        }
+        """);
+
+        object?[] args =
+        {
+            document.RootElement,
+            "005930",
+            null,
+        };
+
+        var result = (bool)method!.Invoke(null, args)!;
+
+        Assert.True(result);
+        var record = Assert.IsType<PriceHistoryDailyRecord>(args[2]);
+        Assert.Equal("005930", record.Ticker);
+        Assert.Equal(new DateOnly(2026, 7, 11), record.TradeDate);
+        Assert.Equal(1000m, record.Open);
+        Assert.Equal(1100m, record.High);
+        Assert.Equal(900m, record.Low);
+        Assert.Equal(1050m, record.Close);
+        Assert.Equal(12345L, record.Volume);
+        Assert.Equal("kis_open_api", record.Source);
+    }
+
+    [Fact]
+    public void TryParseOhlcvBar_WithInvalidBar_ShouldReturnFalse()
+    {
+        var method = typeof(KisDataCollectionOrchestrator).GetMethod(
+            "TryParseOhlcvBar",
+            BindingFlags.NonPublic | BindingFlags.Static);
+
+        Assert.NotNull(method);
+
+        using var document = JsonDocument.Parse("""
+        {
+          "stck_bsop_date": "20260711",
+          "stck_oprc": "1000",
+          "stck_hgpr": "900",
+          "stck_lwpr": "1100",
+          "stck_clpr": "1050",
+          "acml_vol": "12345"
+        }
+        """);
+
+        object?[] args =
+        {
+            document.RootElement,
+            "005930",
+            null,
+        };
+
+        var result = (bool)method!.Invoke(null, args)!;
+
+        Assert.False(result);
+        Assert.Null(args[2]);
+    }
+}
@@ -1,11 +1,13 @@
 using Xunit;
 using Moq;
+using System.Reflection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Hangfire;
 using Hangfire.Common;
 using QuantEngine.Web.Services;
+using QuantEngine.Application.Services;

 namespace QuantEngine.Core.Tests;

@@ -19,16 +21,19 @@ public class SchedulerServiceTests
        var jobClientMock = new Mock<IBackgroundJobClient>();
        var recurringJobManagerMock = new Mock<IRecurringJobManager>();
        var scopeFactoryMock = new Mock<IServiceScopeFactory>();
-        
+
        var configMock = new Mock<IConfiguration>();
        configMock.Setup(c => c["Kis:AccountMode"]).Returns("mock");

+        var parser = new GatherTradingDataParser();
+
        var service = new SchedulerService(
            loggerMock.Object,
            jobClientMock.Object,
            recurringJobManagerMock.Object,
            scopeFactoryMock.Object,
-            configMock.Object
+            configMock.Object,
+            parser
        );

        // Act
@@ -67,4 +72,121 @@ public class SchedulerServiceTests
            It.IsAny<RecurringJobOptions>()
        ), Times.Once);
    }
+
+    [Fact]
+    public void LoadTickersFromJson_WhenFileMissing_FallsBackToDefaultUniverse()
+    {
+        var repoRoot = FindRepoRoot();
+        var jsonPath = Path.Combine(repoRoot, "GatherTradingData.json");
+        var backupPath = jsonPath + ".bak";
+
+        if (File.Exists(jsonPath))
+        {
+            File.Copy(jsonPath, backupPath, true);
+            File.Delete(jsonPath);
+        }
+
+        try
+        {
+            var service = CreateService();
+            var tickers = InvokeLoadTickersFromJson(service);
+
+            Assert.Single(tickers);
+            Assert.Equal("005930", tickers[0]);
+        }
+        finally
+        {
+            if (File.Exists(backupPath))
+            {
+                File.Copy(backupPath, jsonPath, true);
+                File.Delete(backupPath);
+            }
+        }
+    }
+
+    [Fact]
+    public void LoadTickersFromJson_WhenFileExists_ReturnsDistinctTickers()
+    {
+        var repoRoot = FindRepoRoot();
+        var jsonPath = Path.Combine(repoRoot, "GatherTradingData.json");
+        var backupPath = jsonPath + ".bak";
+
+        if (File.Exists(jsonPath))
+        {
+            File.Copy(jsonPath, backupPath, true);
+        }
+
+        try
+        {
+            File.WriteAllText(jsonPath, """
+            {
+              "data": {
+                "data_feed": [
+                  {"Ticker":"005930"},
+                  {"Ticker":"000660"},
+                  {"Ticker":"005930"}
+                ]
+              }
+            }
+            """);
+
+            var service = CreateService();
+            var tickers = InvokeLoadTickersFromJson(service);
+
+            Assert.Equal(new[] { "005930", "000660" }, tickers);
+        }
+        finally
+        {
+            if (File.Exists(backupPath))
+            {
+                File.Copy(backupPath, jsonPath, true);
+                File.Delete(backupPath);
+            }
+            else
+            {
+                File.Delete(jsonPath);
+            }
+        }
+    }
+
+    private static SchedulerService CreateService()
+    {
+        var loggerMock = new Mock<ILogger<SchedulerService>>();
+        var jobClientMock = new Mock<IBackgroundJobClient>();
+        var recurringJobManagerMock = new Mock<IRecurringJobManager>();
+        var scopeFactoryMock = new Mock<IServiceScopeFactory>();
+        var configMock = new Mock<IConfiguration>();
+        configMock.Setup(c => c["Kis:AccountMode"]).Returns("mock");
+
+        return new SchedulerService(
+            loggerMock.Object,
+            jobClientMock.Object,
+            recurringJobManagerMock.Object,
+            scopeFactoryMock.Object,
+            configMock.Object,
+            new GatherTradingDataParser()
+        );
+    }
+
+    private static List<string> InvokeLoadTickersFromJson(SchedulerService service)
+    {
+        var method = typeof(SchedulerService).GetMethod("LoadTickersFromJson", BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(method);
+        return (List<string>)method!.Invoke(service, null)!;
+    }
+
+    private static string FindRepoRoot()
+    {
+        var current = new DirectoryInfo(AppContext.BaseDirectory);
+        while (current != null)
+        {
+            if (Directory.Exists(Path.Combine(current.FullName, ".git")))
+            {
+                return current.FullName;
+            }
+            current = current.Parent;
+        }
+
+        throw new InvalidOperationException("Repository root not found.");
+    }
 }
@@ -53,4 +53,14 @@ public interface ICollectionRepository
    /// Fetch latest snapshots for a ticker across all datasets.
    /// </summary>
    Task<List<CollectionSnapshotRecord>> GetLatestSnapshotsForTickerAsync(string ticker, int limit = 10);
+
+    /// <summary>
+    /// Save daily price history bar (OHLCV). Idempotent via ON CONFLICT DO NOTHING.
+    /// </summary>
+    Task SavePriceHistoryDailyAsync(PriceHistoryDailyRecord record);
+
+    /// <summary>
+    /// Get price history summary per ticker (row count, first/last dates).
+    /// </summary>
+    Task<List<PriceHistorySummaryRecord>> GetPriceHistorySummaryAsync();
 }
@@ -93,3 +93,28 @@ public record CollectionDashboardStateRecord(
    int TotalErrors,
    List<CollectionErrorRecord> RecentErrors
 );
+
+/// <summary>
+/// Daily price history record (OHLCV bar).
+/// </summary>
+public record PriceHistoryDailyRecord(
+    string Ticker,
+    DateOnly TradeDate,
+    decimal Open,
+    decimal High,
+    decimal Low,
+    decimal Close,
+    long Volume,
+    string Source,
+    string? ProvenanceJson = null
+);
+
+/// <summary>
+/// Price history summary (per-ticker aggregation).
+/// </summary>
+public record PriceHistorySummaryRecord(
+    string Ticker,
+    int RowCount,
+    DateOnly FirstDate,
+    DateOnly LastDate
+);
@@ -0,0 +1,29 @@
+using System.Data;
+using Dapper;
+
+namespace QuantEngine.Infrastructure.Data;
+
+/// <summary>
+/// Dapper has no built-in type handler for System.DateOnly: writing a DateOnly parameter
+/// throws NotSupportedException, and reading a DATE column into a DateOnly property throws
+/// InvalidCastException. Register once at startup (SqlMapper.AddTypeHandler) to fix both
+/// directions everywhere in the codebase.
+/// </summary>
+public class DateOnlyTypeHandler : SqlMapper.TypeHandler<DateOnly>
+{
+    public override void SetValue(IDbDataParameter parameter, DateOnly value)
+    {
+        parameter.DbType = DbType.Date;
+        parameter.Value = value.ToDateTime(TimeOnly.MinValue);
+    }
+
+    public override DateOnly Parse(object value)
+    {
+        return value switch
+        {
+            DateOnly d => d,
+            DateTime dt => DateOnly.FromDateTime(dt),
+            _ => DateOnly.Parse(value.ToString()!)
+        };
+    }
+}
@@ -156,6 +156,42 @@ namespace QuantEngine.Infrastructure.Repositories
            )).ToList();
        }

+        public async Task SavePriceHistoryDailyAsync(PriceHistoryDailyRecord record)
+        {
+            using var conn = _connectionFactory.CreateConnection();
+            await conn.ExecuteAsync(@"
+                INSERT INTO quantengine.price_history_daily (ticker, trade_date, open, high, low, close, volume, source, provenance)
+                VALUES (@Ticker, @TradeDate, @Open, @High, @Low, @Close, @Volume, @Source, @Provenance::jsonb)
+                ON CONFLICT (ticker, trade_date) DO NOTHING",
+                new
+                {
+                    record.Ticker,
+                    // Dapper has no built-in type handler for System.DateOnly (throws
+                    // NotSupportedException) — pass as DateTime; the DATE column truncates the time part.
+                    TradeDate = record.TradeDate.ToDateTime(TimeOnly.MinValue),
+                    record.Open,
+                    record.High,
+                    record.Low,
+                    record.Close,
+                    record.Volume,
+                    record.Source,
+                    Provenance = record.ProvenanceJson ?? "{}"
+                }
+            );
+        }
+
+        public async Task<List<PriceHistorySummaryRecord>> GetPriceHistorySummaryAsync()
+        {
+            using var conn = _connectionFactory.CreateConnection();
+            return (await conn.QueryAsync<PriceHistorySummaryRecord>(@"
+                SELECT ticker AS Ticker, count(*)::int AS RowCount, min(trade_date) AS FirstDate, max(trade_date) AS LastDate
+                FROM quantengine.price_history_daily
+                GROUP BY ticker
+                ORDER BY ticker",
+                new { }
+            )).ToList();
+        }
+
        private async Task EnsureTablesAsync()
        {
            using var conn = _connectionFactory.CreateConnection();
@@ -216,6 +216,46 @@ public class GetLatestSnapshotsEndpoint : Endpoint<GetLatestSnapshotsRequest, Ge
    }
 }

+public class GetPriceHistorySummaryResponse
+{
+    public List<PriceHistorySummaryRecord> Tickers { get; set; } = new();
+}
+
+public class GetPriceHistorySummaryEndpoint : EndpointWithoutRequest<GetPriceHistorySummaryResponse>
+{
+    private readonly ICollectionRepository _repo;
+    private readonly ILogger<GetPriceHistorySummaryEndpoint> _logger;
+
+    public GetPriceHistorySummaryEndpoint(ICollectionRepository repo, ILogger<GetPriceHistorySummaryEndpoint> logger)
+    {
+        _repo = repo;
+        _logger = logger;
+    }
+
+    public override void Configure()
+    {
+        Get("/api/collection/history-summary");
+        AllowAnonymous();
+        Description(d => d
+            .Produces<GetPriceHistorySummaryResponse>(200)
+            .Produces(500));
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        try
+        {
+            var summary = await _repo.GetPriceHistorySummaryAsync();
+            await SendOkAsync(new GetPriceHistorySummaryResponse { Tickers = summary }, ct);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to fetch price history summary");
+            await SendErrorsAsync(500, ct);
+        }
+    }
+}
+
 public class StartCollectionRunResponse
 {
    public string RunId { get; set; } = "";
@@ -86,4 +86,46 @@
            </div>
        </div>
    </div>
+
+    <div class="row row-deck row-cards">
+        <div class="col-12">
+            <div class="card">
+                <div class="card-header">
+                    <h3 class="card-title">히스토리 현황</h3>
+                </div>
+                <div class="table-responsive">
+                    <table class="table card-table table-vcenter">
+                        <thead>
+                            <tr>
+                                <th>티커</th>
+                                <th>데이터 수</th>
+                                <th>시작일</th>
+                                <th>종료일</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            @if (Model.HistorySummary?.Any() == true)
+                            {
+                                @foreach (var summary in Model.HistorySummary)
+                                {
+                                    <tr>
+                                        <td>@summary.Ticker</td>
+                                        <td>@summary.RowCount</td>
+                                        <td>@summary.FirstDate:yyyy-MM-dd</td>
+                                        <td>@summary.LastDate:yyyy-MM-dd</td>
+                                    </tr>
+                                }
+                            }
+                            else
+                            {
+                                <tr>
+                                    <td colspan="4" class="text-center text-muted">데이터가 없습니다</td>
+                                </tr>
+                            }
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+    </div>
 </div>
@@ -12,6 +12,7 @@ public class IndexModel : PageModel
    private readonly ILogger<IndexModel> _logger;

    public List<CollectionRunRecord>? Runs { get; set; }
+    public List<PriceHistorySummaryRecord>? HistorySummary { get; set; }
    public string? Message { get; set; }

    public IndexModel(ICollectionRepository collectionRepository, ILogger<IndexModel> logger)
@@ -25,10 +26,11 @@ public class IndexModel : PageModel
        try
        {
            Runs = await _collectionRepository.GetRecentRunsAsync(limit: 20);
+            HistorySummary = await _collectionRepository.GetPriceHistorySummaryAsync();
        }
        catch (Exception ex)
        {
-            _logger.LogError(ex, "Collection runs loading failed");
+            _logger.LogError(ex, "Collection data loading failed");
            Message = "데이터 수집 현황을 불러올 수 없습니다.";
        }
    }
@@ -18,6 +18,9 @@ Log.Logger = new LoggerConfiguration()
    .WriteTo.File("logs/quantengine-.log", rollingInterval: RollingInterval.Day)
    .CreateLogger();

+// Dapper has no built-in handler for System.DateOnly (params or result mapping) — register once globally.
+Dapper.SqlMapper.AddTypeHandler(new DateOnlyTypeHandler());
+
 try
 {
    var builder = WebApplication.CreateBuilder(args);
@@ -21,19 +21,78 @@ public class SchedulerService
    private readonly IRecurringJobManager _recurringJobManager;
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly IConfiguration _configuration;
+    private readonly GatherTradingDataParser _parser;

    public SchedulerService(
        ILogger<SchedulerService> logger,
        IBackgroundJobClient jobClient,
        IRecurringJobManager recurringJobManager,
        IServiceScopeFactory scopeFactory,
-        IConfiguration configuration)
+        IConfiguration configuration,
+        GatherTradingDataParser parser)
    {
        _logger = logger;
        _jobClient = jobClient;
        _recurringJobManager = recurringJobManager;
        _scopeFactory = scopeFactory;
        _configuration = configuration;
+        _parser = parser;
+    }
+
+    private List<string> LoadTickersFromJson()
+    {
+        try
+        {
+            var jsonPath = FindGatherTradingDataJson();
+            if (string.IsNullOrEmpty(jsonPath))
+            {
+                _logger.LogWarning("GatherTradingData.json not found, falling back to default universe");
+                return new List<string> { "005930" };
+            }
+
+            var data = _parser.ParseGatherTradingData(jsonPath);
+            var tickers = new HashSet<string>();
+
+            foreach (var row in data)
+            {
+                if (row.TryGetValue("Ticker", out var tickerObj) && tickerObj is string tickerRaw && !string.IsNullOrEmpty(tickerRaw))
+                {
+                    var ticker = tickerRaw.Trim('"');
+                    if (!string.IsNullOrEmpty(ticker))
+                    {
+                        tickers.Add(ticker);
+                    }
+                }
+            }
+
+            var result = tickers.ToList();
+            _logger.LogInformation("Loaded {Count} tickers from GatherTradingData.json", result.Count);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error loading tickers from GatherTradingData.json, falling back to default universe");
+            return new List<string> { "005930" };
+        }
+    }
+
+    private static string? FindGatherTradingDataJson()
+    {
+        var baseDir = AppContext.BaseDirectory;
+        var current = new DirectoryInfo(baseDir);
+
+        while (current != null)
+        {
+            var gatherPath = Path.Combine(current.FullName, "GatherTradingData.json");
+            if (Directory.Exists(Path.Combine(current.FullName, ".git"))
+                || File.Exists(gatherPath))
+            {
+                return File.Exists(gatherPath) ? gatherPath : null;
+            }
+            current = current.Parent;
+        }
+
+        return null;
    }

    /// <summary>
@@ -94,8 +153,7 @@ public class SchedulerService
        {
            _logger.LogInformation("Starting daily data collection job at {Time}", DateTime.Now);

-            // List of tickers to collect
-            var tickers = new[] { "005930", "000660", "051910", "005380", "010140", "005490" };
+            var tickers = LoadTickersFromJson();

            // Create scope for scoped services
            using var scope = _scopeFactory.CreateScope();
@@ -108,7 +166,7 @@ public class SchedulerService
            var accountMode = _configuration["Kis:AccountMode"] ?? "mock";

            // Execute collection
-            var result = await orchestrator.RunCollectionAsync(runId, accountMode, tickers.ToList());
+            var result = await orchestrator.RunCollectionAsync(runId, accountMode, tickers);

            // Log completion
            _logger.LogInformation("Collection run {RunId} completed: {Snapshots} snapshots, {Errors} errors",
@@ -129,7 +187,7 @@ public class SchedulerService
        {
            _logger.LogInformation("Starting hourly price update at {Time}", DateTime.Now);

-            var tickers = new[] { "005930", "000660", "051910" };
+            var tickers = LoadTickersFromJson();

            foreach (var ticker in tickers)
            {