hourly scoring grid and 13 reference strategies since Jan 1

app/baselines.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+"""참고 전략 — 교과서에 나오는 규칙들을 같은 채점기로 돌린 되돌아보기.
+
+왜 넣는가
+  시즌 초에는 참가자 곡선이 없어 비교 차트가 비어 있다. 그러면 "얼마를 내야
+  잘한 것인가"를 가늠할 기준이 화면에 없다. 널리 알려진 규칙 몇 개를 최근
+  구간에 적용해 깔아 두면 그 자리가 척도가 된다.
+
+🔴 이것은 **과거 구간 재현**이다. 미래 성과가 아니고, 참가자 성적도 아니다.
+   화면에 그 사실을 반드시 함께 적는다. 백테스트를 성적처럼 보여주는 것이
+   이 대회가 없애려는 문제 그 자체다.
+
+🔑 참가자와 **완전히 같은 채점기·같은 수수료**로 돌린다. 규칙만 다르고
+   나머지 조건이 같아야 비교가 성립한다. 수수료를 빼고 그리면 회전이 높은
+   규칙이 부당하게 좋아 보인다.
+
+🔑 어떤 규칙도 미래를 보지 않는다. 모든 신호는 shift(1) 이후에 쓴다.
+   이동평균을 그날 종가로 계산해 그날 포지션에 쓰면 성적이 통째로 거짓이 된다.
+"""
+import numpy as np
+import pandas as pd
+
+# 올해 첫 거래일부터 잰다. "1월 1일에 이 규칙으로 출발했다면 지금 어디인가" 가
+# 굴러가는 90일 창보다 훨씬 읽기 쉽고, 기준점이 고정되어 매일 값이 흔들리지 않는다.
+SINCE = "2026-01-01"
+
+
+def _rsi(p, n=14):
+    d = p.diff()
+    up = d.clip(lower=0).ewm(alpha=1 / n, adjust=False).mean()
+    dn = (-d.clip(upper=0)).ewm(alpha=1 / n, adjust=False).mean()
+    return 100 - 100 / (1 + up / dn.replace(0, np.nan))
+
+
+def _weights(px):
+    """규칙별 포지션 시계열. 전부 전날까지의 정보만 쓴다."""
+    p = pd.Series(px, dtype=float).sort_index()
+    out = {}
+
+    out["BUYHOLD"] = pd.Series(1.0, index=p.index)
+
+    # 200일선 — 단일 규칙으로는 가장 널리 알려진 것. 위면 들고 아래면 비운다.
+    s200 = p.rolling(200).mean()
+    out["SMA200"] = (p > s200).astype(float).shift(1)
+
+    # 골든/데드 크로스 — 50일선이 200일선을 넘으면 롱, 내려가면 숏
+    s50x = p.rolling(50).mean()
+    out["GOLDEN50_200"] = np.sign(s50x - s200).shift(1)
+
+    # 이동평균 교차 — 가장 널리 알려진 추세 규칙
+    s20, s50 = p.rolling(20).mean(), p.rolling(50).mean()
+    out["SMA20_50"] = np.sign(s20 - s50).shift(1)
+
+    # 60일 모멘텀 — 학술 문헌에서 가장 많이 검증된 축
+    out["MOM60"] = np.sign(p / p.shift(60) - 1).shift(1)
+
+    # 돈치안 20일 채널 돌파
+    hi, lo = p.rolling(20).max(), p.rolling(20).min()
+    br = pd.Series(0.0, index=p.index)
+    br[p >= hi] = 1.0
+    br[p <= lo] = -1.0
+    out["DONCHIAN20"] = br.replace(0.0, np.nan).ffill().fillna(0.0).shift(1)
+
+    # RSI 역추세 — 과매도에 사고 과매수에 판다
+    r = _rsi(p)
+    out["RSI14"] = ((50 - r) / 20).clip(-1, 1).shift(1)
+
+    # 볼린저 복귀 — 평균에서 멀어진 만큼 반대로
+    m, sd = p.rolling(20).mean(), p.rolling(20).std()
+    out["BBAND20"] = (-(p - m) / (2 * sd.replace(0, np.nan))).clip(-1, 1).shift(1)
+
+    # MACD (12,26,9) — 오실레이터 중 가장 널리 쓰이는 것.
+    # 히스토그램 부호로 방향을 정한다.
+    e12 = p.ewm(span=12, adjust=False).mean()
+    e26 = p.ewm(span=26, adjust=False).mean()
+    macd = e12 - e26
+    out["MACD"] = np.sign(macd - macd.ewm(span=9, adjust=False).mean()).shift(1)
+
+    # 일목균형표 구름 — 종가만 있으므로 고저 대신 종가의 이동 최고·최저를 쓴다.
+    # 원본 정의와 완전히 같지는 않지만 구름의 위치 판정은 같은 뜻을 유지한다.
+    conv = (p.rolling(9).max() + p.rolling(9).min()) / 2
+    base = (p.rolling(26).max() + p.rolling(26).min()) / 2
+    spa = ((conv + base) / 2).shift(26)
+    spb = ((p.rolling(52).max() + p.rolling(52).min()) / 2).shift(26)
+    top, bot = pd.concat([spa, spb], axis=1).max(axis=1), pd.concat([spa, spb], axis=1).min(axis=1)
+    ich = pd.Series(0.0, index=p.index)
+    ich[p > top] = 1.0
+    ich[p < bot] = -1.0
+    out["ICHIMOKU"] = ich.shift(1)
+
+    # 12개월 절대 모멘텀 — 지난 1년 수익이 양수면 보유, 아니면 비운다.
+    out["ABSMOM12M"] = (p / p.shift(252) - 1 > 0).astype(float).shift(1)
+
+    # 스토캐스틱 (14,3) — 과매수·과매도 판정의 고전
+    lo14, hi14 = p.rolling(14).min(), p.rolling(14).max()
+    k = 100 * (p - lo14) / (hi14 - lo14).replace(0, np.nan)
+    out["STOCH14"] = ((50 - k.rolling(3).mean()) / 25).clip(-1, 1).shift(1)
+
+    # 변동성 타겟팅 — 방향은 롱 고정, 크기만 조절
+    sig = np.log(p).diff().ewm(span=60).std()
+    tgt = sig.iloc[:max(len(sig) // 2, 60)].median()
+    out["VOLTARGET"] = (tgt / sig).clip(0, 1).shift(1)
+
+    return {k: v.fillna(0.0) for k, v in out.items()}
+
+
+LABEL = {
+    "BUYHOLD":      {"ko": "단순 보유",          "en": "Buy and hold"},
+    "SMA200":       {"ko": "200일선 위에서만 보유",
+                     "en": "Hold only above the 200-day MA"},
+    "GOLDEN50_200": {"ko": "골든크로스 50/200",  "en": "Golden cross 50/200"},
+    "SMA20_50":   {"ko": "이동평균 20/50 교차",   "en": "SMA 20/50 crossover"},
+    "MOM60":      {"ko": "60일 모멘텀",          "en": "60-day momentum"},
+    "DONCHIAN20": {"ko": "돈치안 20일 돌파",      "en": "Donchian 20 breakout"},
+    "RSI14":      {"ko": "RSI 14 역추세",        "en": "RSI 14 mean reversion"},
+    "BBAND20":    {"ko": "볼린저 20 복귀",        "en": "Bollinger 20 reversion"},
+    "MACD":       {"ko": "MACD 12/26/9",        "en": "MACD 12/26/9"},
+    "ICHIMOKU":   {"ko": "일목균형표 구름",        "en": "Ichimoku cloud"},
+    "ABSMOM12M":  {"ko": "12개월 절대 모멘텀",     "en": "12-month absolute momentum"},
+    "STOCH14":    {"ko": "스토캐스틱 14/3",       "en": "Stochastic 14/3"},
+    "VOLTARGET":  {"ko": "변동성 타겟팅",         "en": "Volatility targeting"},
+}
+ORDER = ["BUYHOLD", "SMA200", "GOLDEN50_200", "SMA20_50", "MACD", "ICHIMOKU",
+         "MOM60", "ABSMOM12M", "DONCHIAN20", "RSI14", "STOCH14", "BBAND20",
+         "VOLTARGET"]
+
+
+def curves(px, asset, scoring, lang="ko", since=SINCE):
+    """올해 첫 거래일부터 지금까지. 참가자와 같은 엔진·같은 수수료로 계산한다.
+
+    🔑 지표 계산에는 그 이전 데이터도 쓴다 — 1월 2일의 200일선은 작년 값이
+       있어야 나온다. 잘라낸 뒤에 지표를 만들면 연초 구간이 통째로 비고,
+       그러면 규칙이 시작하지도 않은 상태로 그려진다.
+    """
+    p = pd.Series(px, dtype=float).sort_index()
+    if len(p) < 300:                       # 252일 모멘텀 + 여유
+        return {"t": [], "series": []}
+    w = _weights(p)                        # 전 구간으로 지표를 만든 뒤에
+    idx = p.index[p.index >= pd.Timestamp(since)]      # 표시 구간만 자른다
+    if len(idx) < 5:
+        return {"t": [], "series": []}
+    seg = p.loc[idx]
+    out = []
+    for k in ORDER:
+        pos = {t: float(w[k].loc[t]) for t in idx}
+        eq, _ = scoring.equity(pos, seg, asset)
+        out.append({
+            "key": k,
+            "label": LABEL[k]["en" if lang == "en" else "ko"],
+            "v": [round(float(x - 1) * 100, 4) for x in eq],
+            "ret": round(float(eq.iloc[-1] - 1) * 100, 2),
+            "turnover": round(scoring.turnover(pos, seg), 1),
+            "fee": round(scoring.fee_paid(pos, seg, asset) * 100, 2),
+        })
+    out.sort(key=lambda x: -x["ret"])
+    return {"t": [t.isoformat() for t in idx], "series": out,
+            "since": str(idx[0].date()), "window": len(idx),
+            "market": [round(float(x), 4) for x in (seg / seg.iloc[0] - 1) * 100]}

app/fetch.py

@@ -91,6 +91,35 @@ def _gecko(cid, days):
     return s[~s.index.duplicated(keep="last")]
 
 
+def _feed_h(sym, bars):
+    """시간봉 피드. 채점 격자가 이걸 쓴다.
+
+    🔑 일봉으로 채점하면 개막일에 하루를 통째로 기다려야 첫 수익률이 나온다.
+       규칙에는 '매시간 갱신 가능'이라고 써 놓고 채점만 일 단위이면 어긋난다.
+    """
+    import os
+    from huggingface_hub import hf_hub_download
+    repo = os.environ.get("FINCHAL_FEED", "FINAL-Bench/finchal-prices")
+    tok = os.environ.get("HF_TOKEN") or os.environ.get("FINCHAL_HF_TOKEN")
+    f = hf_hub_download(repo, "prices_1h/%s.csv" % sym, repo_type="dataset", token=tok)
+    d = pd.read_csv(f)
+    s = pd.Series(d["close"].values, index=pd.to_datetime(d["ts"])).dropna()
+    s = s[~s.index.duplicated(keep="last")].sort_index()
+    return s.iloc[-bars:]
+
+
+def hourly(asset, bars=2000):
+    """시간봉. 피드에만 있다. 없으면 None 을 돌려주고 호출부가 일봉으로 내려간다."""
+    sym = MAP.get(asset, {}).get("feed")
+    if not sym:
+        return None
+    try:
+        s = _feed_h(sym, bars)
+        return s if len(s) >= 24 else None
+    except Exception:
+        return None
+
+
 def _feed(sym, days):
     """우리가 발행한 시세 피드. 공개 소스가 전부 막힌 서버에서는 이게 유일한 길이다.
 

app/main.py

@@ -20,6 +20,7 @@ import ledger as L
 import mcp as MCP
 import fetch as FE
 import i18n as I
+import baselines as BL
 
 CEIL = json.load(open(os.path.join(os.path.dirname(HERE), "announce_ceiling.json"),
                      encoding="utf-8"))["ceiling"]
@@ -72,10 +73,34 @@ def prices(asset, interval="1d", bars=800):
     return _PX["d"][k].iloc[-bars:]
 
 
+_HX = {"at": 0.0, "d": {}}
+
+
+def hourly_px(asset):
+    """시간봉 캐시. 채점 격자가 이걸 쓴다."""
+    if time.time() - _HX["at"] > 600:
+        _HX["d"].clear(); _HX["at"] = time.time()
+    if asset not in _HX["d"]:
+        _HX["d"][asset] = FE.hourly(asset, 2000)
+    return _HX["d"][asset]
+
+
 def season_px(asset):
-    """시즌 개막 이후 구간만. 채점과 기준분포가 이걸 본다."""
-    s = prices(asset, "1d", 2000)
-    return s[s.index >= pd.Timestamp(S1["opens"])]
+    """시즌 개막 이후 구간. 채점과 기준분포가 이걸 본다.
+
+    🔑 시간봉이 있으면 시간봉으로 잰다. 일봉으로 채점하면 개막일에 하루를
+       통째로 기다려야 첫 수익률이 나오는데, 규칙은 '매시간 갱신 가능'이라고
+       말하고 있다. 재는 단위와 약속한 단위가 다르면 안 된다.
+       시간봉이 아직 없는 종목은 일봉으로 내려간다 — 비어 있는 것보다 낫다.
+    """
+    op = pd.Timestamp(S1["opens"])
+    h = hourly_px(asset)
+    if h is not None and len(h):
+        sub = h[h.index >= op]
+        if len(sub) >= 2:
+            return sub
+    d = prices(asset, "1d", 2000)
+    return d[d.index >= op]
 
 
 def rules_doc(lang="ko"):
@@ -342,9 +367,17 @@ def set_lang(code: str):
 def api_data(asset: str, bars: int = 500, interval: str = "1d"):
     if asset not in ASSETS:
         return JSONResponse({"ok": False, "error": "알 수 없는 종목"}, 400)
+    if interval == "1h":
+        h = hourly_px(asset)
+        if h is None or not len(h):
+            return JSONResponse({"ok": False,
+                                 "error": "시간봉 없음 / no hourly bars yet"}, 400)
+        return {"ok": True, "asset": asset, "interval": "1h",
+                "bars": [{"t": t.isoformat(), "c": float(v)}
+                         for t, v in h.iloc[-min(max(bars, 10), 5000):].items()]}
     if interval != "1d":
         return JSONResponse({"ok": False,
-                             "error": "일봉만 제공합니다 / daily bars only"}, 400)
+                             "error": "1d 또는 1h / 1d or 1h only"}, 400)
     s = prices(asset, interval, min(max(bars, 10), 5000))
     return {"ok": True, "asset": asset, "interval": interval,
             "bars": [{"t": t.isoformat(), "c": float(v)} for t, v in s.items()]}
@@ -414,6 +447,22 @@ def api_curves(asset: str, top: int = 12):
     return {"ok": True, "asset": asset, **curves(asset, top)}
 
 
+_BLC = {}
+
+
+@app.get("/api/baselines")
+def api_baselines(request: Request, asset: str, lang: str = None):
+    """교과서 규칙들을 최근 구간에 적용한 되돌아보기. 참가자 곡선의 척도로 쓴다."""
+    if asset not in ASSETS:
+        return JSONResponse({"ok": False, "error": "알 수 없는 종목"}, 400)
+    g = lang_of(request, lang)
+    k = "%s|%s" % (asset, g)
+    e = _BLC.get(k)
+    if not e or time.time() - e[0] > 1800:
+        _BLC[k] = (time.time(), BL.curves(prices(asset, "1d", 400), asset, SC, g))
+    return {"ok": True, "asset": asset, **_BLC[k][1]}
+
+
 @app.get("/api/manifesto")
 def api_manifesto(request: Request, lang: str = None):
     g = lang_of(request, lang)
@@ -444,12 +493,22 @@ def _call(name, args, key=None, lang="ko"):
         if a not in ASSETS:
             return {"error": T(I.HINT["unknown_asset"]) % list(ASSETS)}
         iv = args.get("interval", "1d")
+        n = min(args.get("bars", 500), 5000)
+        if iv == "1h":
+            h = hourly_px(a)
+            if h is None or not len(h):
+                return {"error": ("이 종목은 아직 시간봉이 없습니다. '1d' 를 쓰십시오."
+                                  if lang == "ko" else
+                                  "No hourly bars for this asset yet. Use '1d'.")}
+            return {"asset": a, "interval": "1h",
+                    "bars": [{"t": t.isoformat(sep=" "), "c": round(float(v), 6)}
+                             for t, v in h.iloc[-n:].items()]}
         if iv != "1d":
             # 요청을 조용히 무시하지 않는다. 못 주는 것은 못 준다고 말한다.
-            return {"error": ("일봉만 제공합니다. interval 은 '1d' 만 가능합니다."
+            return {"error": ("interval 은 '1d' 또는 '1h' 만 가능합니다."
                               if lang == "ko" else
-                              "Only daily bars are served. interval must be '1d'.")}
-        s = prices(a, iv, min(args.get("bars", 500), 5000))
+                              "interval must be '1d' or '1h'.")}
+        s = prices(a, iv, n)
         return {"asset": a, "interval": "1d",
                 "bars": [{"t": t.date().isoformat(), "c": round(float(v), 6)}
                          for t, v in s.items()]}

app/mcp.py

@@ -44,8 +44,10 @@ TOOLS = [
                 # 🔴 시간봉을 목록에 두면 안 된다. 우리 시세 피드는 일봉만 발행하는데
                 #    1h 를 받아 놓고 일봉을 돌려주면 에이전트는 시간봉으로 믿고
                 #    모델을 세운다. 조용히 틀린 답이 가장 나쁘다.
-                "interval": {"type": "string", "enum": ["1d"], "default": "1d",
-                             "description": "일봉만 제공합니다 / daily bars only"},
+                "interval": {"type": "string", "enum": ["1d", "1h"], "default": "1d",
+                             "description": "일봉 또는 시간봉. 채점은 시간봉 격자에서 "
+                                            "이뤄집니다 / daily or hourly; scoring runs "
+                                            "on the hourly grid"},
             },
             "required": ["asset"],
         },

app/static/index.html

@@ -228,6 +228,8 @@ pre{background:#0f1729;color:#e6edf7;border-radius:11px;padding:14px 16px;overfl
       <div class="kpis" id="kpis"></div>
       <div id="chart"></div>
       <div class="legend" id="legend"></div>
+      <div class="note" id="bl-note" style="margin-top:14px"></div>
+      <div id="bl-table" style="margin-top:10px"></div>
     </div>
 
     <div>
@@ -348,6 +350,11 @@ var S = {
          "아래를 그대로 붙여넣으십시오.",
   creed:"이 대회는 답을 모으지 않습니다. 경계를 잽니다.",
   pending:"집계 전",
+  blNote:function(d, l){ return "<b>참고 · " + d + " 부터 지금까지</b> — 올해 첫 거래일에 " +
+    "이 규칙들로 " + l + " 을 시작했다면 지금 어디인지를, <b>참가자와 똑같은 채점기·" +
+    "똑같은 수수료</b>로 계산한 값입니다. 모든 신호는 전날까지의 정보만 씁니다. " +
+    "이것은 과거 구간 재현이며 미래 성과도, 참가자 성적도 아닙니다."; },
+  blTh:["참고 전략","연초 대비","회전율","수수료"],
   pendingNote:"시즌이 오늘 열렸습니다. 접수된 포지션은 아래와 같고, 수익률은 " +
               "하루치 구간이 쌓이는 대로 계산되어 순위가 매겨집니다.",
   tv:"실시간 시세", tvSub:"TradingView 제공 · 채점에 쓰는 것과 같은 종목",
@@ -398,6 +405,12 @@ var S = {
          "Paste the block below.",
   creed:"This contest does not collect answers. It measures the boundary.",
   pending:"pending",
+  blNote:function(d, l){ return "<b>Reference · since " + d + "</b> — where these rules " +
+    "would stand today had you started them on " + l + " at the first trading day of the " +
+    "year, computed through <b>the same scorer and the same fees</b> entrants face. Every " +
+    "signal uses information available the day before. This is a replay of the past, not " +
+    "future performance and not an entrant result."; },
+  blTh:["Reference strategy","Since Jan 1","Turnover","Fees"],
   pendingNote:"The season opened today. Positions received so far are listed below; " +
               "returns and ranks appear once a full day of data accumulates.",
   tv:"Live market", tvSub:"By TradingView · the same instrument we score",
@@ -743,11 +756,14 @@ async function drawChart(a){
     leg.push([col, x.user + " · " + x.strategy, x.v[x.v.length - 1]]);
   });
   chart.timeScale().fitContent();
-  $("legend").innerHTML = leg.length
-    ? leg.map(function(e){
-        return '<span><i style="background:' + e[0] + '"></i>' + e[1] +
-          ' <b class="mono ' + cls(e[2]) + '">' + fmt(e[2]) + "</b></span>"; }).join("")
-    : '<span class="faint">' + s.noCurve + "</span>";
+  $("legend").innerHTML = leg.map(function(e){
+      return '<span><i style="background:' + e[0] + '"></i>' + e[1] +
+        ' <b class="mono ' + cls(e[2]) + '">' + fmt(e[2]) + "</b></span>"; }).join("");
+
+  /* 참가자 곡선이 아직 없으면 교과서 규칙들을 대신 깔아 척도를 만든다.
+     🔴 이건 과거 재현이지 참가자 성적이 아니다. 그 사실을 화면에 적는다. */
+  if (!(d.series || []).length) { drawBaselines(a); }
+  else { $("bl-note").textContent = ""; $("bl-table").innerHTML = ""; }
 
   var rows = d.series || [];
   var best = rows.length ? Math.max.apply(null, rows.map(function(x){
@@ -763,6 +779,53 @@ async function drawChart(a){
       x[2] + '">' + x[1] + "</div></div>"; }).join("");
 }
 
+async function drawBaselines(a){
+  var s = L();
+  var d = await (await fetch("/api/baselines?asset=" + a + "&lang=" + LANG)).json();
+  if (!d.series || !d.series.length) {
+    $("legend").innerHTML = '<span class="faint">' + s.noCurve + "</span>";
+    return;
+  }
+  var el = $("chart");
+  if (chart) { chart.remove(); chart = null; }
+  chart = LightweightCharts.createChart(el, {
+    layout:{background:{color:"#ffffff"}, textColor:C.dim, fontSize:11},
+    grid:{vertLines:{color:C.line}, horzLines:{color:C.line}},
+    rightPriceScale:{borderColor:C.line},
+    timeScale:{borderColor:C.line, timeVisible:false},
+    crosshair:{mode:1}, height:el.clientHeight});
+  var t = d.t.map(function(x){ return x.slice(0, 10); });
+  var add = function(vals, color, w, dash){
+    var ss = chart.addLineSeries({color:color, lineWidth:w, lineStyle:dash ? 2 : 0,
+      priceLineVisible:false, lastValueVisible:false});
+    ss.setData(t.map(function(x, i){ return {time:x, value:vals[i]}; }));
+  };
+  var leg = [];
+  if (d.market) {
+    add(d.market, C.dim, 2, true);
+    leg.push([C.dim, s.market(R.assets[a].label), d.market[d.market.length - 1]]);
+  }
+  d.series.forEach(function(x, i){
+    var col = C.pal[i % C.pal.length];
+    add(x.v, col, 2, false);
+    leg.push([col, x.label, x.ret]);
+  });
+  chart.timeScale().fitContent();
+  $("legend").innerHTML = leg.map(function(e){
+    return '<span><i style="background:' + e[0] + '"></i>' + e[1] +
+      ' <b class="mono ' + cls(e[2]) + '">' + fmt(e[2]) + "</b></span>"; }).join("");
+  $("bl-note").innerHTML = s.blNote(d.since || "", R.assets[a].label);
+  $("bl-table").innerHTML =
+    '<div class="tw"><table><thead><tr><th>' + s.blTh[0] + "</th>" +
+    '<th class="num">' + s.blTh[1] + '</th><th class="num">' + s.blTh[2] +
+    '</th><th class="num">' + s.blTh[3] + "</th></tr></thead><tbody>" +
+    d.series.map(function(x){
+      return "<tr><td>" + x.label + '</td><td class="num mono ' + cls(x.ret) +
+        '"><b>' + fmt(x.ret) + '</b></td><td class="num mono faint">' + x.turnover +
+        '</td><td class="num mono ' + (x.fee > 2 ? "dn" : "faint") + '">−' +
+        x.fee.toFixed(2) + "%</td></tr>"; }).join("") + "</tbody></table></div>";
+}
+
 async function drawRank(a){
   var s = L();
   var d = await (await fetch("/api/leaderboard?asset=" + a)).json();