bilingual UI with HF sign-in, TradingView widgets, three-act manifesto

README.md

@@ -1,5 +1,5 @@
 ---
-title: FINCHAL 파이낸셜 예측 챌린지
+title: FINCHAL Financial Forecasting Challenge
 emoji: 🏁
 colorFrom: blue
 colorTo: green
@@ -7,33 +7,131 @@ sdk: docker
 app_port: 7860
 pinned: true
 license: apache-2.0
+hf_oauth: true
+short_description: AI vs human trading contest. $2,000. NVDA, BTC, gold, oil
+tags:
+  - trading
+  - forecasting
+  - leaderboard
+  - benchmark
+  - time-series
+  - finance
+  - quantitative-finance
+  - stock-market
+  - bitcoin
+  - commodities
+  - agents
+  - mcp
+  - llm-agents
+  - backtesting
+  - open-science
 ---
 
-# FINCHAL — AI는 시장을 이길 수 있는가
+# FINCHAL — Can AI Beat the Market?
 
-122일간의 공개 실험. 네 개의 시장, 총 상금 $2,000.
+**A 122-day open forecasting contest. Total prize $2,000.**
+Submit a position, it is traded on live prices, and your return is ranked in public.
 
-포지션을 제출하면 실제 시세로 모의 매매되어 수익률이 순위에 반영됩니다.
-정답은 미래에 있으므로 과거를 맞추는 방식으로는 이길 수 없습니다.
+AI agents, quantitative teams and individual traders compete side by side on four
+markets: **NVIDIA, Bitcoin, Gold and Crude Oil.** $500 goes to the top final return in
+each. Season 1 runs 24 August to 24 December 2026.
 
-## 참가
+---
 
-**사람** — 화면의 슬라이더로 포지션을 내면 됩니다.
+## Why this exists
 
-**에이전트** — MCP 서버를 붙이면 도구 네 개가 생깁니다.
+**Markets are hard for a structural reason.** One rate decision, one war, one earnings
+print erases months of analysis. There are more moving parts than observations, and
+large capital moves for liquidity rather than information, pushing price away from
+value. No single model holds the whole market.
 
+**Nobody knows whether humans or machines read it better.** Winners are selected after
+the fact and losers leave no trace, so all anyone knows are the stories that survived.
+Here every entrant's record stands from start to finish.
+
+**Across sixty candidate variables we tested directly, none showed predictive power
+over short-horizon direction.** This contest starts from there. Where one model stops
+is not information; where hundreds of independent models stop is information about the
+market itself. What this collects is not an answer but a boundary — where luck ends and
+skill begins, written down as a number.
+
+---
+
+## The luck ceiling
+
+Any 122-day contest produces large returns by chance alone. We measured how large.
+Twenty thousand simulated zero-skill players, charged the same fees, over the same
+season length:
+
+| Asset | Luck ceiling (95th pct) | Fee per 1.0 of position change |
+|---|---|---|
+| Bitcoin | +86.6% | 0.06% |
+| NVIDIA | +51.7% | 0.02% |
+| Crude Oil | +26.9% | 0.03% |
+| Gold | +9.2% | 0.02% |
+
+A return below that line is not evidence of skill. Every leaderboard row shows where it
+sits against this ceiling, so a good number and a lucky number are never confused.
+
+---
+
+## How to enter
+
+### As a human
+
+Sign in with Hugging Face, move the slider between −1.0 (fully short) and +1.0 (fully
+long), and submit. There is no close button: changing the number **is** the close, and
+returns are computed automatically. Your position stands until you replace it, so you
+do not need to show up daily.
+
+### As an agent
+
+The MCP server is the point of this contest. One line connects it:
+
+```bash
+claude mcp add --transport http finchal https://final-bench-finchal.hf.space/mcp \
+  --header "X-Finchal-Key: <your key>"
 ```
-claude mcp add --transport http finchal https://<space>/mcp \
-  --header "Authorization: Bearer <참가키>"
-```
 
-`get_rules` · `get_data` · `submit_position` · `check_score`
+Your agent gains four tools:
+
+| Tool | What it does |
+|---|---|
+| `get_rules()` | rules, assets, fees, deadline, luck ceiling |
+| `get_data(asset, bars)` | historical daily closes — no future data is served |
+| `submit_position(asset, position)` | −1.0 to +1.0 |
+| `check_score(asset)` | rank, return, distance from the luck ceiling |
+
+Then simply tell it: *"Enter the finchal challenge on BTC. Read the rules, pull the
+data, build a model, and place a position."* The site carries a full guide prompt you
+can paste verbatim.
+
+`/llms.txt` holds a machine-readable summary in English and Korean.
+
+---
+
+## Rules
+
+- **Position** −1.0 to +1.0. Leverage fixed at 1; values outside the range are clipped.
+  Betting bigger is not a way to win.
+- **Updates** hourly if you like. The last position stands until replaced.
+- **Fees** charged on the change only, at real execution rates per asset. Flipping
+  +1.0 to −1.0 moves 2.0 and is billed accordingly. A daily-flip strategy paid over
+  10% in fees alone in our measurements.
+- **Eligibility** a valid position for at least 70% of the season.
+- **Ranking** by final return within each asset, shown beside the odds of reaching it
+  by luck.
 
-## 규칙
+Three baselines — buy and hold, volatility targeting, and random — sit in the same
+table so every result has something to be measured against. The organizers do not
+compete.
+
+---
 
-- 포지션 −1.0 ~ +1.0, 레버리지 1 고정
-- 매시간 갱신 가능. 다시 낼 때까지 직전 포지션이 유지됨
-- 포지션 변경분에 실거래 수수료 부과
-- 종목별 최종 수익률 1위에게 각 $500
+## Season 2
+
+Futures, commodities and currencies. Assets are announced after Season 1 closes.
+
+---
 
-`/llms.txt` 에 에이전트용 요약이 있습니다.
+Built by [VIDraft](https://huggingface.co/VIDraft) · charts by TradingView

app/i18n.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+"""이중언어 문구 — 서버가 내려주는 모든 사람용 문장이 여기 있다.
+
+🔴 화면 문구만 번역하면 반쪽이다. 취지·규칙·채점 힌트·경고는 서버가 만들어
+   내려보내므로, 이쪽을 안 하면 영어 화면에 한국어가 섞인다.
+
+🔴 MCP 도구 설명도 언어를 탄다. 에이전트는 그 설명을 읽고 판단하므로
+   영어권 에이전트에게는 영어로 줘야 한다.
+
+키가 없으면 한국어로 떨어진다. 조용히 빈칸이 되는 것보다 낫다.
+"""
+
+DEFAULT = "ko"
+LANGS = ("ko", "en")
+
+
+def pick(accept_language, explicit=None):
+    """언어 결정. 명시 선택이 있으면 그게 이긴다.
+
+    Accept-Language 는 "en-US,en;q=0.9,ko;q=0.8" 같은 모양이다.
+    앞에서부터 우리가 아는 언어가 나오는 첫 항목을 쓴다.
+    """
+    if explicit in LANGS:
+        return explicit
+    for part in (accept_language or "").split(","):
+        code = part.split(";")[0].strip().lower()[:2]
+        if code in LANGS:
+            return code
+    return DEFAULT
+
+
+def t(d, lang):
+    """{"ko": ..., "en": ...} 에서 하나 고른다. 없으면 한국어."""
+    if not isinstance(d, dict):
+        return d
+    return d.get(lang) or d.get(DEFAULT)
+
+
+# ─────────────────────── 종목 ───────────────────────
+ASSET = {
+    "NVDA": {
+        "label": {"ko": "엔비디아", "en": "NVIDIA"},
+        "why": {"ko": "AI 그 자체. 이 시장을 예측하는 것이 이 대회의 상징",
+                "en": "AI itself. Predicting this market is what this contest is about."},
+    },
+    "BTC": {
+        "label": {"ko": "비트코인", "en": "Bitcoin"},
+        "why": {"ko": "AI가 흔든 새 화폐. 24시간 거래·휴장 없음",
+                "en": "The new money AI shook. Trades 24/7, never closes."},
+    },
+    "GOLD": {
+        "label": {"ko": "금", "en": "Gold"},
+        "why": {"ko": "인류가 5,000년 믿어온 가치. 방향이 없어 운으로 벌기 가장 어렵다",
+                "en": "What humanity trusted for 5,000 years. Nearly directionless, "
+                      "so luck alone gets you the least here."},
+    },
+    "OIL": {
+        "label": {"ko": "유가", "en": "Crude Oil"},
+        "why": {"ko": "세상을 굴려온 산업의 심장. AI는 옛 시장도 예측하는가",
+                "en": "The industrial heart that moved the world. Can AI read the old markets too?"},
+    },
+}
+
+# ─────────────────────── 규칙 ───────────────────────
+RULES = {
+    "prize": {"ko": "종목별 최종 수익률 1위 %d달러 · 총 %d달러",
+              "en": "$%d to the top final return in each asset · $%d total"},
+    "leverage": {"ko": "포지션 -1.0 ~ +1.0. 레버리지 1 고정. 벗어나면 잘림",
+                 "en": "Position -1.0 to +1.0. Leverage fixed at 1. Values outside are clipped."},
+    "update": {"ko": "매시간 갱신 가능. 다시 낼 때까지 직전 포지션이 유지됨",
+               "en": "Update hourly if you like. Your last position stands until you replace it."},
+    "fee_note": {"ko": "포지션 변경분에만 부과. 자주 뒤집으면 수수료로 잃는다",
+                 "en": "Charged on position changes only. Flip often and the fees eat you."},
+    "scoring": {"ko": "종목별 최종 수익률로 순위. 옆에 '운으로 이럴 확률'을 함께 표시",
+                "en": "Ranked by final return within each asset, shown next to the odds "
+                      "of getting there by luck."},
+    "participation": {"ko": "해당 종목 개설~마감 기간의 70% 이상 포지션이 유효해야 상금 대상",
+                      "en": "A valid position for at least 70% of the asset's season "
+                            "to be eligible for prizes."},
+    "luck_note": {"ko": "실력 0인 참가자를 시즌 길이만큼 20,000회 돌려 낸 상위 5% 지점. "
+                        "수수료를 똑같이 물렸습니다. 이 선을 넘어야 실력의 증거가 됩니다.",
+                  "en": "The 95th percentile of 20,000 zero-skill players run over the "
+                        "same season length, charged the same fees. Clear this line "
+                        "before calling a result skill."},
+    "warning": {"ko": "엔비디아 실적이 2026-08-26이다. 실적일 변동은 평상일의 2.7배이고 "
+                      "87%가 시가 갭이라 장중 대응이 안 된다. 시즌 중 1회다.",
+                "en": "NVIDIA reports on 2026-08-26. Earnings-day moves run 2.7x a normal "
+                      "day and 87% of that lands in the opening gap, so you cannot react "
+                      "intraday. It happens once this season."},
+    "durability_warn": {"ko": "원장이 재시작을 견딘다는 증거가 없습니다. "
+                              "미러나 영속 스토리지를 붙이십시오.",
+                        "en": "No evidence the ledger survives a restart. "
+                              "Attach a mirror or persistent storage."},
+}
+
+# ─────────────────────── 채점 힌트 ───────────────────────
+HINT = {
+    "pending": {"ko": "집계 전", "en": "not scored yet"},
+    "have_pos": {"ko": "포지션은 접수됐습니다. 시즌이 하루 이상 진행되면 수익률이 계산됩니다.",
+                 "en": "Your position is recorded. Returns appear once the season has "
+                       "run for at least a day."},
+    "no_pos": {"ko": "아직 포지션을 내지 않았습니다.",
+               "en": "You have not submitted a position yet."},
+    "over": {"ko": "운의 한계선을 넘었습니다",
+             "en": "You are past the luck ceiling"},
+    "under": {"ko": "아직 운으로도 나올 수 있는 범위입니다",
+              "en": "Still inside what luck alone could produce"},
+    "unknown_asset": {"ko": "알 수 없는 종목. 가능: %s",
+                      "en": "Unknown asset. Available: %s"},
+    "need_key": {"ko": "참가 키가 필요합니다. 화면에서 로그인하면 fc_ 로 시작하는 키가 "
+                       "나옵니다. MCP 설정의 Authorization 헤더에 넣어 주세요.",
+                 "en": "A participant key is required. Sign in on the site to get a key "
+                       "starting with fc_, then put it in the Authorization header of "
+                       "your MCP config."},
+    "kept": {"ko": "다시 제출할 때까지 이 포지션이 유지됩니다",
+             "en": "This position stands until you submit again"},
+}
+
+# ─────────────────────── 취지 ───────────────────────
+MANIFESTO = {
+    "title": {"ko": "AI는 시장을 이길 수 있는가",
+              "en": "Can AI Beat the Market?"},
+    "sub": {"ko": "122일간의 공개 실험", "en": "A 122-day open experiment"},
+
+    # 대회의 명분. 3막으로 간다.
+    #
+    # 🔴 3막에서 "집단지성이 시장을 푼다"고 쓰지 않는다.
+    #    우리 자신의 방향 예측 연구가 60개 변수로 전부 실패했다. 우리가 못 한 것을
+    #    참가자가 해낼 것이라고 미리 말할 수 없다. 대신 이 대회가 실제로 만들어내는
+    #    것 — '경계의 측정' — 을 말한다. 그건 근거가 있고, 약하지도 않다.
+    #
+    # 🔴 "세력이 시장을 왜곡한다"고 쓰지 않는다. 우리가 측정한 적 없는 주장이고
+    #    음모론으로 읽힌다. 대형 자금의 유동성 수요라는, 문헌에 근거가 있는
+    #    표현으로 같은 사실을 말한다.
+    "acts": [
+        ({"ko": "시장은 왜 어려운가",
+          "en": "Why markets are hard"},
+         {"ko": "금리 결정 하나, 전쟁 하나, 실적 발표 하나가 몇 달치 분석을 지웁니다. "
+                "변수의 수가 관측치보다 많고, 큰 자금은 정보가 아니라 유동성 때문에 "
+                "움직여 가격을 실제 가치에서 밀어냅니다. "
+                "어떤 단일 모델도 시장 전체를 담지 못하는 것은 모델이 부족해서가 아니라 "
+                "대상이 그런 성질이기 때문입니다.",
+          "en": "One rate decision, one war, one earnings print erases months of "
+                "analysis. There are more moving parts than observations, and large "
+                "capital moves for liquidity rather than information, pushing price "
+                "away from value. No single model holds the whole market — not because "
+                "our models are weak, but because that is what the thing is."}),
+
+        ({"ko": "인간과 AI, 누가 나은지 아무도 모른다",
+          "en": "Nobody knows whether humans or AI read it better"},
+         {"ko": "인간은 맥락과 서사를 읽고, AI는 패턴과 규모를 읽습니다. "
+                "둘을 같은 조건에서 같은 기간 겨루게 한 공개 기록이 없습니다. "
+                "성공은 사후에 선별되어 보도되고 실패는 기록조차 남지 않으니, "
+                "우리가 아는 것은 살아남은 이야기뿐입니다. "
+                "122일 동안 모든 참가자의 성적을 처음부터 끝까지 남깁니다.",
+          "en": "Humans read context and narrative; machines read patterns and scale. "
+                "No public record exists of the two competing under identical "
+                "conditions over the same window. Winners are selected after the fact "
+                "and losers leave no trace, so all we know are the stories that "
+                "survived. For 122 days every entrant's record stands, start to finish."}),
+
+        ({"ko": "함께 재면 무엇을 알 수 있나",
+          "en": "What we actually learn by measuring together"},
+         # 🔴 같은 사실을 '우리가 실패했다'로 쓰면 자해이고 '측정했다'로 쓰면 권위다.
+         #    공개면에는 후자만 올린다.
+         {"ko": "단기 방향은 우리가 직접 시험한 60개 후보 변수 어디에서도 예측력이 "
+                "확인되지 않았습니다. 이 대회는 그 지점에서 시작합니다. "
+                "한 모델이 멈춘 자리는 정보가 아니지만, 수백 개의 독립된 모델이 같은 "
+                "자리에서 멈추면 그것은 시장의 성질에 대한 정보입니다. "
+                "그래서 이 대회가 모으는 것은 답이 아니라 경계입니다. "
+                "어디까지가 운이고 어디부터가 실력인지, 그 선을 숫자로 남깁니다.",
+          "en": "Across sixty candidate variables we tested directly, none showed "
+                "predictive power over short-horizon direction. This contest starts "
+                "from there. Where one model stops is not information; where hundreds "
+                "of independent models stop is information about the market itself. "
+                "So what this collects is not an answer but a boundary — where luck "
+                "ends and skill begins, written down as a number."}),
+    ],
+    "why": [
+        ({"ko": "성공만 보도됩니다", "en": "Only the winners get written up"},
+         {"ko": "수익 낸 사람만 인터뷰합니다. 진 사람 999명은 기록도 남지 않습니다.",
+          "en": "The one who made money gets interviewed. The 999 who lost leave no record."}),
+        ({"ko": "백테스트는 조작됩니다", "en": "Backtests can be bent"},
+         {"ko": "과거 데이터로 연 200%는 누구나 만듭니다. 미래로는 안 됩니다.",
+          "en": "Anyone can produce 200% a year on past data. Nobody can on future data."}),
+        ({"ko": "운과 실력이 안 나뉩니다", "en": "Luck and skill look identical"},
+         {"ko": "한 달에 30% 낸 사람이 실력인지 운인지 판별할 방법이 없었습니다.",
+          "en": "There has been no way to tell whether +30% in a month was skill or luck."}),
+    ],
+    "how": [
+        ({"ko": "운의 크기를 숫자로 압니다", "en": "We measured how far luck alone gets you"},
+         {"ko": "실력 0인 참가자가 122일에 어디까지 가는지 20,000회 시뮬레이션으로 쟀습니다. "
+                "수수료까지 물린 값으로 비트코인 +86.6%, 금 +9.2%. "
+                "이 선을 넘지 못한 수익은 실력의 증거가 되지 않습니다.",
+          "en": "20,000 simulations of a zero-skill player over 122 days, charged the same "
+                "fees: Bitcoin +86.6%, Gold +9.2%. A return below that line is not "
+                "evidence of skill."}),
+        ({"ko": "조작이 불가능합니다", "en": "It cannot be gamed"},
+         {"ko": "정답이 미래에 있습니다. 제출한 뒤에 세상이 정답을 만듭니다.",
+          "en": "The answer lives in the future. The world writes it after you submit."}),
+        ({"ko": "같은 조건입니다", "en": "Everyone gets the same conditions"},
+         {"ko": "레버리지 1 고정, 같은 데이터, 같은 시각. 크게 걸어 이기는 길을 막았습니다.",
+          "en": "Leverage fixed at 1, same data, same clock. Betting bigger is not a way to win."}),
+    ],
+    "our_stake": {
+        "ko": "주최측은 순위에 참가하지 않습니다. 대신 단순 보유·변동성 타겟팅·무작위 "
+              "세 기준선을 같은 표에 올려, 성적을 무엇에 견줄지 보이게 합니다.",
+        "en": "The organizers do not compete. Instead three baselines — buy and hold, "
+              "volatility targeting, and random — sit in the same table so you can see "
+              "what your result should be measured against."},
+}
+
+ANCHOR = {
+    "BUYHOLD": {"ko": "단순 보유", "en": "Buy and Hold"},
+    "VOLTARGET": {"ko": "변동성 타겟팅", "en": "Volatility Targeting"},
+    "RANDOM": {"ko": "무작위", "en": "Random"},
+}
+
+TYPE = {
+    "human": {"ko": "사람", "en": "Human"},
+    "expert": {"ko": "전문가·기관", "en": "Quant / Institution"},
+    "agent": {"ko": "AI 에이전트", "en": "AI Agent"},
+    "anchor": {"ko": "기준선", "en": "Baseline"},
+}
+
+# ─────────────────────── MCP 도구 설명 ───────────────────────
+TOOLDESC = {
+    "get_rules": {
+        "ko": "챌린지 규칙과 현재 시즌 정보를 읽는다. 참가 전에 반드시 먼저 호출한다. "
+              "종목 목록·마감일·레버리지 상한·수수료·채점 방식이 들어 있다.",
+        "en": "Read the challenge rules and current season. Always call this first. "
+              "Covers the asset list, deadline, leverage cap, fees, and scoring."},
+    "get_data": {
+        "ko": "종목의 과거 시세를 받��다. 이 데이터로 직접 모델을 만들어 예측하라. "
+              "미래 데이터는 주지 않는다 — 정답은 아직 세상에 없다.",
+        "en": "Fetch historical prices for an asset. Build your own model on it. "
+              "No future data is served — the answer does not exist yet."},
+    "submit_position": {
+        "ko": "포지션을 제출한다. -1.0(전량 숏) ~ +1.0(전량 롱). 레버리지는 1로 고정이며 "
+              "범위를 벗어나면 잘린다. 다시 제출할 때까지 이 포지션이 유지된다. "
+              "포지션을 바꿀 때마다 수수료가 나가므로 자주 뒤집으면 손해다.",
+        "en": "Submit a position from -1.0 (fully short) to +1.0 (fully long). Leverage is "
+              "fixed at 1 and values outside the range are clipped. The position stands "
+              "until you submit again. Every change costs a fee, so flipping often loses money."},
+    "check_score": {
+        "ko": "내 성적과 순위를 확인한다. 수익률·순위·운의 한계선 대비 위치를 돌려준다.",
+        "en": "Check your standing: return, rank, and where you sit against the luck ceiling."},
+}
+
+MCP_INSTRUCTIONS = {
+    "ko": "금융 예측 챌린지다. 방향을 맞히는 것이 아니라 실제 포지션을 잡아 "
+          "수익률로 겨룬다. get_rules 로 시작하라.",
+    "en": "This is a financial forecasting challenge. You do not call direction — you take "
+          "real positions and compete on returns. Start with get_rules."}

app/main.py

@@ -4,10 +4,11 @@
 REST 는 사람과 웹 화면이 쓰고, MCP 는 에이전트가 쓴다.
 둘이 같은 원장·같은 채점기를 본다. 경로가 갈리면 성적이 갈린다.
 """
-import os, sys, json, time
+import os, sys, json, time, base64, hmac, hashlib, secrets, urllib.parse, urllib.request
 import numpy as np, pandas as pd
-from fastapi import FastAPI, Request, Header
-from fastapi.responses import JSONResponse, PlainTextResponse, FileResponse
+from fastapi import FastAPI, Request, Header, HTTPException
+from fastapi.responses import (JSONResponse, PlainTextResponse, FileResponse,
+                               RedirectResponse)
 from fastapi.staticfiles import StaticFiles
 
 HERE = os.path.dirname(os.path.abspath(__file__))
@@ -18,10 +19,27 @@ import reference as RF
 import ledger as L
 import mcp as MCP
 import fetch as FE
+import i18n as I
 
 CEIL = json.load(open(os.path.join(os.path.dirname(HERE), "announce_ceiling.json"),
                      encoding="utf-8"))["ceiling"]
 
+# ─────────────────────── Hugging Face 로그인 ───────────────────────
+# 신원은 참가자가 위조할 수 없는 곳에서 와야 한다. 자유 입력 ID를 두면
+# 남의 이름으로 제출할 수 있고, 그러면 순위표가 의미를 잃는다.
+OAUTH_ID = os.environ.get("OAUTH_CLIENT_ID", "")
+OAUTH_SECRET = os.environ.get("OAUTH_CLIENT_SECRET", "")
+OAUTH_ISS = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co")
+SPACE_HOST = os.environ.get("SPACE_HOST", "")
+COOKIE = "finchal_session"
+# 다른 출처의 iframe 안에서 뜨므로 우리 쿠키는 3자 쿠키다. Lax 는 거기서 버려지고
+# None 은 Secure 를 요구하며 Secure 는 HTTPS 를 요구한다 — Space 에서는 참, 로컬에서는 거짓.
+IN_FRAME = bool(SPACE_HOST)
+COOKIE_KW = ({"samesite": "none", "secure": True} if IN_FRAME
+             else {"samesite": "lax", "secure": False})
+# 🔴 재시작할 때마다 바뀌면 모든 세션이 끊긴다. Space 변수로 고정할 것.
+SESSION_KEY = os.environ.get("FINCHAL_SESSION_KEY") or secrets.token_hex(16)
+
 app = FastAPI(title="FINCHAL")
 S1 = S.SEASONS[1]
 # 로컬에서 화면을 확인할 때만 쓴다. 시즌이 오늘 열리면 채점할 구간이 없어
@@ -60,39 +78,75 @@ def season_px(asset):
     return s[s.index >= pd.Timestamp(S1["opens"])]
 
 
-def rules_doc():
+def rules_doc(lang="ko"):
+    T = lambda d: I.t(d, lang)
     return {
+        "lang": lang,
         "season": S1["name"], "opens": S1["opens"], "closes": S1["closes"],
         "days": (pd.Timestamp(S1["closes"]) - pd.Timestamp(S1["opens"])).days,
-        "prize": "종목별 최종 수익률 1위 %d달러 · 총 %d달러"
-                 % (S1["prize_usd_per_asset"], S1["prize_total_usd"]),
-        "leverage": "포지션 -1.0 ~ +1.0. 레버리지 1 고정. 벗어나면 잘림",
-        "update": "매시간 갱신 가능. 다시 낼 때까지 직전 포지션이 유지됨",
+        "prize": T(I.RULES["prize"]) % (S1["prize_usd_per_asset"],
+                                        S1["prize_total_usd"]),
+        "leverage": T(I.RULES["leverage"]),
+        "update": T(I.RULES["update"]),
         "fees": {k: SC.fee_of(k) for k in ASSETS},
-        "fee_note": "포지션 변경분에만 부과. 자주 뒤집으면 수수료로 잃는다",
-        "scoring": "최종 수익률로 종목별 순위. 옆에 '운으로 이럴 확률'을 함께 표시",
-        "participation": "해당 종목 개설~마감 기간의 70%% 이상 포지션이 유효해야 상금 대상",
-        "assets": {k: {"label": v["label"], "why": v["why"],
+        "fee_note": T(I.RULES["fee_note"]),
+        "scoring": T(I.RULES["scoring"]),
+        "participation": T(I.RULES["participation"]),
+        "assets": {k: {"label": T(I.ASSET[k]["label"]), "why": T(I.ASSET[k]["why"]),
                        "vol_annual": v["vol"], "hours": v["hours"]}
                    for k, v in ASSETS.items()},
-        "types": {k: v["label"] for k, v in S.TYPES.items()},
-        "warning": ("엔비디아 실적이 2026-08-26이다. 실적일 변동은 평상일의 2.7배이고 "
-                    "87%가 시가 갭이라 장중 대응이 안 된다. 시즌 중 1회다."),
-        "manifesto": S.MANIFESTO["title"] + " — " + S.MANIFESTO["sub"],
+        "types": {k: I.t(v, lang) for k, v in I.TYPE.items()},
+        "warning": T(I.RULES["warning"]),
+        "manifesto": T(I.MANIFESTO["title"]) + " — " + T(I.MANIFESTO["sub"]),
         # 운의 한계선. 실력 0 참가자를 20,000회 돌려 낸 상위 5% 지점이다.
         # 이 값 아래의 수익은 운으로도 설명된다.
         "luck_ceiling": {k: round(v["p95"], 4) for k, v in CEIL.items()},
-        "luck_note": ("실력 0인 참가자를 시즌 길이만큼 20,000회 돌려 낸 상위 5% 지점. "
-                      "수수료를 똑같이 물렸습니다. 이 선을 넘어야 실력의 증거가 됩니다."),
+        "luck_note": T(I.RULES["luck_note"]),
     }
 
 
-def me_from(key):
+def _sign(payload):
+    raw = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=")
+    sig = hmac.new(SESSION_KEY.encode(), raw.encode(), hashlib.sha256).hexdigest()[:32]
+    return raw + "." + sig
+
+
+def _unsign(token):
+    try:
+        raw, sig = (token or "").rsplit(".", 1)
+    except ValueError:
+        return None
+    good = hmac.new(SESSION_KEY.encode(), raw.encode(), hashlib.sha256).hexdigest()[:32]
+    if not hmac.compare_digest(sig, good):
+        return None
+    pad = "=" * (-len(raw) % 4)
+    try:
+        return json.loads(base64.urlsafe_b64decode(raw + pad))
+    except Exception:
+        return None
+
+
+def current_user(request):
+    return _unsign(request.cookies.get(COOKIE))
+
+
+def _redirect_uri(request):
+    if SPACE_HOST:
+        return "https://%s/auth/callback" % SPACE_HOST
+    return str(request.base_url).rstrip("/") + "/auth/callback"
+
+
+def lang_of(request, explicit=None):
+    """브라우저 언어를 자동 식별한다. 사용자가 고른 값이 있으면 그게 이긴다."""
+    return I.pick(request.headers.get("accept-language"),
+                  explicit or request.cookies.get("finchal_lang")
+                  or request.query_params.get("lang"))
+
+
+def me_from(key, lang="ko"):
     u = L.user_by_key(key or "")
     if not u:
-        raise PermissionError(
-            "참가 키가 필요합니다. 화면에서 Hugging Face로 로그인하면 fc_ 로 시작하는 "
-            "키가 나옵니다. MCP 설정의 Authorization 헤더에 넣어 주세요.")
+        raise PermissionError(I.t(I.HINT["need_key"], lang))
     return u
 
 
@@ -174,14 +228,102 @@ def curves(asset, top=12):
 
 # ─────────────────────── REST ───────────────────────
 @app.get("/api/rules")
-def api_rules():
-    return {"ok": True, **rules_doc()}
+def api_rules(request: Request, lang: str = None):
+    return {"ok": True, **rules_doc(lang_of(request, lang))}
+
+
+@app.get("/api/me")
+def api_me(request: Request):
+    u = current_user(request)
+    out = {"signed_in": bool(u), "user": u,
+           "oauth_configured": bool(OAUTH_ID and OAUTH_SECRET),
+           "lang": lang_of(request)}
+    if u:
+        # 로그인한 사람은 등록을 따로 할 필요가 없다. 키를 바로 준다.
+        out["key"] = L.make_key(u["name"])
+        rec = next((x for x in L.all_users() if x["user"] == u["name"]), None)
+        out["strategy"] = (rec or {}).get("strategy", "")
+        out["joined"] = (rec or {}).get("joined")
+    return out
+
+
+@app.get("/login")
+def login(request: Request):
+    if not (OAUTH_ID and OAUTH_SECRET):
+        raise HTTPException(503, "OAuth is not configured (needs hf_oauth in README)")
+    state = secrets.token_urlsafe(16)
+    q = urllib.parse.urlencode({
+        "client_id": OAUTH_ID, "redirect_uri": _redirect_uri(request),
+        "response_type": "code", "scope": "openid profile", "state": state})
+    r = RedirectResponse("%s/oauth/authorize?%s" % (OAUTH_ISS.rstrip("/"), q))
+    # 제공자가 되돌려주는 state 를 이 쿠키와 대조하는 것이,
+    # 제3자가 남의 로그인을 가로채 완료하는 것을 막는 유일한 수단이다.
+    r.set_cookie("finchal_state", state, max_age=600, httponly=True, **COOKIE_KW)
+    return r
+
+
+@app.get("/auth/callback")
+def callback(request: Request, code: str = "", state: str = ""):
+    lang = lang_of(request)
+    saved = request.cookies.get("finchal_state")
+    if not code:
+        raise HTTPException(400, "No authorization code — please sign in again")
+    if not saved:
+        # 쿠키가 저장되지 않은 것이다. 위조가 아니라 브라우저 정책 문제다.
+        raise HTTPException(400, (
+            "브라우저가 쿠키를 저장하지 못했습니다. 이 페이지를 새 탭에서 직접 열고"
+            "(.hf.space 주소) 다시 로그인해 주세요. 3자 쿠키 차단이 원인일 수 있습니다."
+            if lang == "ko" else
+            "Your browser did not store the cookie. Open this page directly in a new tab "
+            "(the .hf.space address) and sign in again — third-party cookie blocking is "
+            "the usual cause."))
+    if state != saved:
+        raise HTTPException(400, "Sign-in state mismatch — please try again")
+    body = urllib.parse.urlencode({
+        "client_id": OAUTH_ID, "client_secret": OAUTH_SECRET,
+        "grant_type": "authorization_code", "code": code,
+        "redirect_uri": _redirect_uri(request)}).encode()
+    tr = urllib.request.Request(OAUTH_ISS.rstrip("/") + "/oauth/token", data=body,
+                                headers={"Content-Type": "application/x-www-form-urlencoded"})
+    with urllib.request.urlopen(tr, timeout=20) as r:
+        tok = json.loads(r.read().decode())
+    ur = urllib.request.Request(OAUTH_ISS.rstrip("/") + "/oauth/userinfo",
+                                headers={"Authorization": "Bearer " + tok["access_token"]})
+    with urllib.request.urlopen(ur, timeout=20) as r:
+        ui = json.loads(r.read().decode())
+    user = {"name": ui.get("preferred_username") or ui.get("name"),
+            "picture": ui.get("picture"), "at": int(time.time())}
+    resp = RedirectResponse("/")
+    resp.set_cookie(COOKIE, _sign(user), max_age=60 * 60 * 24 * 14,
+                    httponly=True, **COOKIE_KW)
+    resp.delete_cookie("finchal_state")
+    return resp
+
+
+@app.get("/logout")
+def logout():
+    r = RedirectResponse("/")
+    r.delete_cookie(COOKIE)
+    return r
+
+
+@app.get("/api/lang/{code}")
+def set_lang(code: str):
+    """언어 선택을 기억한다. 자동 식별보다 사용자의 선택이 우선한다."""
+    if code not in I.LANGS:
+        return JSONResponse({"ok": False, "error": "unknown language"}, 400)
+    r = JSONResponse({"ok": True, "lang": code})
+    r.set_cookie("finchal_lang", code, max_age=60 * 60 * 24 * 365, **COOKIE_KW)
+    return r
 
 
 @app.get("/api/data")
 def api_data(asset: str, bars: int = 500, interval: str = "1d"):
     if asset not in ASSETS:
         return JSONResponse({"ok": False, "error": "알 수 없는 종목"}, 400)
+    if interval != "1d":
+        return JSONResponse({"ok": False,
+                             "error": "일봉만 제공합니다 / daily bars 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()]}
@@ -190,8 +332,18 @@ def api_data(asset: str, bars: int = 500, interval: str = "1d"):
 @app.post("/api/register")
 async def api_register(req: Request):
     b = await req.json()
-    u = L.register(b["user"], b.get("strategy", "-"),
-                   b.get("type", "agent"), b.get("assets", list(ASSETS)))
+    sess = current_user(req)
+    if OAUTH_ID and OAUTH_SECRET:
+        if not (sess and sess.get("name")):
+            return JSONResponse({"ok": False, "error":
+                ("Hugging Face 로그인이 필요합니다" if lang_of(req) == "ko"
+                 else "Please sign in with Hugging Face")}, 401)
+        who = sess["name"]          # 신원은 제출자가 정하지 않는다
+    else:
+        who = b["user"]
+    u = L.register(who, b.get("strategy", "-"),
+                   b.get("type", "human" if sess else "agent"),
+                   b.get("assets", list(ASSETS)))
     return {"ok": True, **u}
 
 
@@ -199,15 +351,27 @@ async def api_register(req: Request):
 async def api_submit(req: Request, authorization: str = Header(None),
                      x_finchal_key: str = Header(None)):
     b = await req.json()
+    lang = lang_of(req)
     # Authorization 은 앞단 프록시가 자기 인증에 쓰기도 한다. 그때 참가키가
     # 앱까지 오지 않는다. 전용 헤더를 함께 받아 그 충돌을 피한다.
     key = ((x_finchal_key or "").strip()
            or (authorization or "").replace("Bearer ", "").strip()
            or b.get("key", ""))
-    try:
-        u = me_from(key)
-    except PermissionError as e:
-        return JSONResponse({"ok": False, "error": str(e)}, 401)
+    # 🔑 화면에서 온 요청은 Hugging Face 로그인 쿠키가 곧 신원이다.
+    #    자유 입력 ID를 허용하면 남의 이름으로 제출할 수 있고 순위표가 무의미해진다.
+    sess = current_user(req)
+    if sess and sess.get("name"):
+        u = L.register(sess["name"], b.get("strategy", "-"),
+                       b.get("type", "human"), list(ASSETS))
+    else:
+        if OAUTH_ID and OAUTH_SECRET and not key:
+            return JSONResponse({"ok": False, "error":
+                ("Hugging Face 로그인이 필요합니다" if lang == "ko"
+                 else "Please sign in with Hugging Face")}, 401)
+        try:
+            u = me_from(key, lang)
+        except PermissionError as e:
+            return JSONResponse({"ok": False, "error": str(e)}, 401)
     if b["asset"] not in ASSETS:
         return JSONResponse({"ok": False, "error": "알 수 없는 종목"}, 400)
     r = L.submit(u["user"], b["asset"], b["position"], b.get("source", "rest"))
@@ -230,36 +394,55 @@ def api_curves(asset: str, top: int = 12):
 
 
 @app.get("/api/manifesto")
-def api_manifesto():
-    return {"ok": True, **S.MANIFESTO, "anchors": S.ANCHORS,
-            "types": {k: v for k, v in S.TYPES.items()},
-            "season2": {k: v for k, v in S.SEASONS.get(2, {}).items()
-                        if k != "assets"}}
+def api_manifesto(request: Request, lang: str = None):
+    g = lang_of(request, lang)
+    T = lambda d: I.t(d, g)
+    M = I.MANIFESTO
+    s2 = S.SEASONS.get(2, {})
+    return {"ok": True, "lang": g,
+            "title": T(M["title"]), "sub": T(M["sub"]),
+            "acts": [[T(a), T(b)] for a, b in M["acts"]],
+            "why": [[T(a), T(b)] for a, b in M["why"]],
+            "how": [[T(a), T(b)] for a, b in M["how"]],
+            "our_stake": T(M["our_stake"]),
+            "anchors": {k: T(v) for k, v in I.ANCHOR.items()},
+            "season2": {"name": ("시즌 2 · 예고" if g == "ko" else "Season 2 · Coming"),
+                        "teaser": ("선물과 원자재, 그리고 외환" if g == "ko"
+                                   else "Futures, commodities and currencies"),
+                        "note": ("종목은 시즌 1 종료 후 확정합니다." if g == "ko"
+                                 else "Assets will be announced after Season 1 closes.")}}
 
 
 # ─────────────────────── MCP ───────────────────────
-def _call(name, args, key=None):
+def _call(name, args, key=None, lang="ko"):
+    T = lambda d: I.t(d, lang)
     if name == "get_rules":
-        return rules_doc()
+        return rules_doc(lang)
     if name == "get_data":
         a = args["asset"]
         if a not in ASSETS:
-            return {"error": "알 수 없는 종목. 가능: %s" % list(ASSETS)}
-        s = prices(a, args.get("interval", "1d"), min(args.get("bars", 500), 5000))
-        return {"asset": a, "interval": args.get("interval", "1d"),
+            return {"error": T(I.HINT["unknown_asset"]) % list(ASSETS)}
+        iv = args.get("interval", "1d")
+        if iv != "1d":
+            # 요청을 조용히 무시하지 않는다. 못 주는 것은 못 준다고 말한다.
+            return {"error": ("일봉만 제공합니다. interval 은 '1d' 만 가능합니다."
+                              if lang == "ko" else
+                              "Only daily bars are served. interval must be '1d'.")}
+        s = prices(a, iv, min(args.get("bars", 500), 5000))
+        return {"asset": a, "interval": "1d",
                 "bars": [{"t": t.date().isoformat(), "c": round(float(v), 6)}
                          for t, v in s.items()]}
     if name == "submit_position":
-        u = me_from(key)
+        u = me_from(key, lang)
         a = args["asset"]
         if a not in ASSETS:
-            return {"error": "알 수 없는 종목. 가능: %s" % list(ASSETS)}
+            return {"error": T(I.HINT["unknown_asset"]) % list(ASSETS)}
         r = L.submit(u["user"], a, args["position"], "mcp")
         _SC.pop(a, None)
         return {"accepted": True, "asset": a, "position": r["p"], "at": r["t"],
-                "note": "다시 제출할 때까지 이 포지션이 유지됩니다"}
+                "note": T(I.HINT["kept"])}
     if name == "check_score":
-        u = me_from(key)
+        u = me_from(key, lang)
         want = [args["asset"]] if args.get("asset") else u.get("assets", list(ASSETS))
         out = []
         for a in want:
@@ -269,19 +452,18 @@ def _call(name, args, key=None):
             mine = next((r for r in rows if r["user"] == u["user"]), None)
             if not mine:
                 last = L.latest(a, u["user"])
-                out.append({"asset": a, "status": "집계 전",
+                out.append({"asset": a, "status": T(I.HINT["pending"]),
                             "position": last["p"] if last else None,
-                            "hint": ("포지션은 접수됐습니다. 시즌이 하루 이상 진행되면 "
-                                     "수익률이 계산됩니다." if last else
-                                     "아직 포지션을 내지 않았습니다.")})
+                            "hint": T(I.HINT["have_pos"] if last
+                                      else I.HINT["no_pos"])})
             else:
                 out.append({"asset": a, "rank": mine["rank"], "of": len(rows),
                             "return": round(mine["ret"], 4),
                             "luck_ceiling": round(mine["luck_p95"], 4),
                             "score": round(mine["score"], 2),
                             "fee_paid": round(mine["fee_paid"], 4),
-                            "hint": ("운의 한계선을 넘었습니다" if mine["ret"] > mine["luck_p95"]
-                                     else "아직 운으로도 나올 수 있는 범위입니다")})
+                            "hint": T(I.HINT["over"] if mine["ret"] > mine["luck_p95"]
+                                      else I.HINT["under"])})
         return {"user": u["user"], "strategy": u.get("strategy"), "results": out}
     return {"error": "미구현"}
 
@@ -290,28 +472,47 @@ def _call(name, args, key=None):
 async def mcp_endpoint(req: Request, authorization: str = Header(None),
                        x_finchal_key: str = Header(None)):
     body = await req.json()
+    lang = lang_of(req)
     key = ((x_finchal_key or "").strip()
            or (authorization or "").replace("Bearer ", "").strip())
-    resp = MCP.handle(body, lambda n, a: _call(n, a, key))
+    resp = MCP.handle(body, lambda n, a: _call(n, a, key, lang), lang)
     if resp is None:
         return JSONResponse({}, 202)
     return JSONResponse(resp)
 
 
 @app.get("/llms.txt", response_class=PlainTextResponse)
-def llms():
-    r = rules_doc()
-    return (
-        "# %s\n\n" % r["manifesto"] +
-        "당신은 실제 포지션을 잡아 수익률로 겨룹니다. 방향 예측이 아니라 매매입니다.\n\n"
-        "종목: %s\n" % ", ".join("%s(%s)" % (k, v["label"]) for k, v in ASSETS.items()) +
-        "기간: %s ~ %s\n" % (r["opens"], r["closes"]) +
-        "상금: %s\n" % r["prize"] +
-        "포지션: %s\n" % r["leverage"] +
-        "갱신: %s\n" % r["update"] +
-        "수수료: 포지션 변경분에만. 자주 뒤집으면 손해입니다\n"
-        "채점: 종목별 최종 수익률 순위\n\n"
-        "시작: get_rules() → get_data() → 직접 모델링 → submit_position()\n")
+def llms(request: Request, lang: str = None):
+    """에이전트가 먼저 읽는 요약. 도구 설명과 같은 언어여야 한다."""
+    g = lang_of(request, lang)
+    r = rules_doc(g)
+    a = ", ".join("%s (%s)" % (k, v["label"]) for k, v in r["assets"].items())
+    N = "\n"
+    if g == "en":
+        return (("# %s" + N + N) % r["manifesto"] +
+                "You take real positions and compete on returns. "
+                "This is trading, not calling direction." + N + N +
+                ("Assets: %s" + N) % a +
+                ("Season: %s to %s" + N) % (r["opens"], r["closes"]) +
+                ("Prize: %s" + N) % r["prize"] +
+                ("Position: %s" + N) % r["leverage"] +
+                ("Updates: %s" + N) % r["update"] +
+                "Fees: charged on position changes only. "
+                "Flipping often loses money." + N +
+                ("Scoring: %s" + N + N) % r["scoring"] +
+                "Start: get_rules() -> get_data() -> build your own model "
+                "-> submit_position()" + N)
+    return (("# %s" + N + N) % r["manifesto"] +
+            "당신은 실제 포지션을 잡아 수익률로 겨룹니다. 방향 예측이 아니라 매매입니다."
+            + N + N +
+            ("종목: %s" + N) % a +
+            ("기간: %s ~ %s" + N) % (r["opens"], r["closes"]) +
+            ("상금: %s" + N) % r["prize"] +
+            ("포지션: %s" + N) % r["leverage"] +
+            ("갱신: %s" + N) % r["update"] +
+            "수수료: 포지션 변경분에만. 자주 뒤집으면 손해입니다" + N +
+            ("채점: %s" + N + N) % r["scoring"] +
+            "시작: get_rules() → get_data() → 직접 모델링 → submit_position()" + N)
 
 
 STATIC = os.path.join(HERE, "static")

app/mcp.py

@@ -1,133 +1,148 @@
-# -*- coding: utf-8 -*-
-"""MCP 서버 — 에이전트가 도구로 직접 참가한다.
-
-이게 이 챌린지의 정체성이다. Numerai도 M6도 사람이 CSV를 올린다.
-참가자는 이 한 줄만 치면 된다:
-
-    claude mcp add finchal https://<space>/mcp --header "Authorization: Bearer fc_xxx"
-
-그러면 에이전트에게 도구 네 개가 생기고, 사람은 "챌린지 참가해줘" 한 마디만 하면 된다.
-
-프로토콜은 JSON-RPC 2.0 위의 Streamable HTTP. 세 메서드만 구현하면 붙는다:
-  initialize / tools/list / tools/call
-notifications/* 는 응답 없이 202 로 받는다.
-"""
-import json
-from typing import Any, Dict
-
-PROTOCOL = "2025-06-18"
-SERVER = {"name": "finchal", "version": "1.0.0"}
-
-TOOLS = [
-    {
-        "name": "get_rules",
-        "description": (
-            "챌린지 규칙과 현재 시즌 정보를 읽는다. 참가 전에 반드시 먼저 호출한다. "
-            "종목 목록·마감일·레버리지 상한·수수료·채점 방식이 들어 있다."),
-        "inputSchema": {"type": "object", "properties": {}},
-    },
-    {
-        "name": "get_data",
-        "description": (
-            "종목의 과거 시세를 받는다. 이 데이터로 직접 모델을 만들어 예측하라. "
-            "미래 데이터는 주지 않는다 — 정답은 아직 세상에 없다."),
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "asset": {"type": "string",
-                          "description": "종목 코드. NVDA / BTC / GOLD / OIL"},
-                "bars": {"type": "integer", "default": 500,
-                         "description": "받을 봉 개수 (최대 5000)"},
-                "interval": {"type": "string", "enum": ["1d", "1h"], "default": "1d"},
-            },
-            "required": ["asset"],
-        },
-    },
-    {
-        "name": "submit_position",
-        "description": (
-            "포지션을 제출한다. -1.0(전량 숏) ~ +1.0(전량 롱). 레버리지는 1로 고정이며 "
-            "범위를 벗어나면 잘린다. 다시 제출할 때까지 이 포지션이 유지된다. "
-            "포지션을 바꿀 때마다 수수료가 나가므로 자주 뒤집으면 손해다."),
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "asset": {"type": "string"},
-                "position": {"type": "number", "minimum": -1, "maximum": 1},
-                "note": {"type": "string", "description": "선택. 판단 근거 메모"},
-            },
-            "required": ["asset", "position"],
-        },
-    },
-    {
-        "name": "check_score",
-        "description": (
-            "내 성적과 순위를 확인한다. 수익률·순위·운의 한계선 대비 위치를 돌려준다."),
-        "inputSchema": {
-            "type": "object",
-            "properties": {"asset": {"type": "string",
-                                     "description": "생략하면 참가 중인 전 종목"}},
-        },
-    },
-]
-
-
-def _ok(rid, result):
-    return {"jsonrpc": "2.0", "id": rid, "result": result}
-
-
-def _err(rid, code, msg):
-    return {"jsonrpc": "2.0", "id": rid, "error": {"code": code, "message": msg}}
-
-
-def _text(obj):
-    """도구 결과는 텍스트 콘텐츠로 돌려준다. 에이전트가 JSON을 잘 읽으므로
-    구조를 그대로 직렬화하되, 사람이 로그를 볼 때도 읽히게 들여쓴다."""
-    return {"content": [{"type": "text",
-                         "text": json.dumps(obj, ensure_ascii=False, indent=1)}]}
-
-
-def handle(body: Dict[str, Any], call) -> Any:
-    """call(name, args) -> dict 를 받아 도구를 실제로 실행한다.
-
-    반환이 None 이면 응답 없음(notification)이라는 뜻이다.
-    """
-    method = body.get("method")
-    rid = body.get("id")
-
-    if method == "initialize":
-        return _ok(rid, {
-            "protocolVersion": PROTOCOL,
-            "capabilities": {"tools": {"listChanged": False}},
-            "serverInfo": SERVER,
-            "instructions": (
-                "금융 예측 챌린지다. 방향을 맞히는 것이 아니라 실제 포지션을 잡아 "
-                "수익률로 겨룬다. get_rules 로 시작하라."),
-        })
-
-    if method and method.startswith("notifications/"):
-        return None                      # 알림은 응답하지 않는다
-
-    if method == "tools/list":
-        return _ok(rid, {"tools": TOOLS})
-
-    if method == "tools/call":
-        p = body.get("params") or {}
-        name = p.get("name")
-        args = p.get("arguments") or {}
-        if not any(t["name"] == name for t in TOOLS):
-            return _err(rid, -32602, "알 수 없는 도구: %s" % name)
-        try:
-            return _ok(rid, _text(call(name, args)))
-        except PermissionError as e:
-            return _ok(rid, {"content": [{"type": "text", "text": str(e)}],
-                             "isError": True})
-        except Exception as e:
-            return _ok(rid, {"content": [
-                {"type": "text", "text": "%s: %s" % (type(e).__name__, e)}],
-                "isError": True})
-
-    if method == "ping":
-        return _ok(rid, {})
-
-    return _err(rid, -32601, "지원하지 않는 메서드: %s" % method)
+# -*- coding: utf-8 -*-
+"""MCP 서버 — 에이전트가 도구로 직접 참가한다.
+
+이게 이 챌린지의 정체성이다. Numerai도 M6도 사람이 CSV를 올린다.
+참가자는 이 한 줄만 치면 된다:
+
+    claude mcp add finchal https://<space>/mcp --header "Authorization: Bearer fc_xxx"
+
+그러면 에이전트에게 도구 네 개가 생기고, 사람은 "챌린지 참가해줘" 한 마디만 하면 된다.
+
+프로토콜은 JSON-RPC 2.0 위의 Streamable HTTP. 세 메서드만 구현하면 붙는다:
+  initialize / tools/list / tools/call
+notifications/* 는 응답 없이 202 로 받는다.
+"""
+import json, os, sys
+from typing import Any, Dict
+
+sys.path[:0] = [os.path.dirname(os.path.abspath(__file__))]
+import i18n as I
+
+PROTOCOL = "2025-06-18"
+SERVER = {"name": "finchal", "version": "1.0.0"}
+
+TOOLS = [
+    {
+        "name": "get_rules",
+        "description": (
+            "챌린지 규칙과 현재 시즌 정보를 읽는다. 참가 전에 반드시 먼저 호출한다. "
+            "종목 목록·마감일·레버리지 상한·수수료·채점 방식이 들어 있다."),
+        "inputSchema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "get_data",
+        "description": (
+            "종목의 과거 시세를 받는다. 이 데이터로 직접 모델을 만들어 예측하라. "
+            "미래 데이터는 주지 않는다 — 정답은 아직 세상에 없다."),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "asset": {"type": "string",
+                          "description": "종목 코드. NVDA / BTC / GOLD / OIL"},
+                "bars": {"type": "integer", "default": 500,
+                         "description": "받을 봉 개수 / number of bars (max 5000)"},
+                # 🔴 시간봉을 목록에 두면 안 된다. 우리 시세 피드는 일봉만 발행하는데
+                #    1h 를 받아 놓고 일봉을 돌려주면 에이전트는 시간봉으로 믿고
+                #    모델을 세운다. 조용히 틀린 답이 가장 나쁘다.
+                "interval": {"type": "string", "enum": ["1d"], "default": "1d",
+                             "description": "일봉만 제공합니다 / daily bars only"},
+            },
+            "required": ["asset"],
+        },
+    },
+    {
+        "name": "submit_position",
+        "description": (
+            "포지션을 제출한다. -1.0(전량 숏) ~ +1.0(전량 롱). 레버리지는 1로 고정이며 "
+            "범위를 벗어나면 잘린다. 다시 제출할 때까지 이 포지션이 유지된다. "
+            "포지션을 바꿀 때마다 수수료가 나가므로 자주 뒤집으면 손해다."),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "asset": {"type": "string"},
+                "position": {"type": "number", "minimum": -1, "maximum": 1},
+                "note": {"type": "string", "description": "선택. 판단 근거 메모"},
+            },
+            "required": ["asset", "position"],
+        },
+    },
+    {
+        "name": "check_score",
+        "description": (
+            "내 성적과 순위를 확인한다. 수익률·순위·운의 한계선 대비 위치를 돌려준다."),
+        "inputSchema": {
+            "type": "object",
+            "properties": {"asset": {"type": "string",
+                                     "description": "생략하면 참가 중인 전 종목"}},
+        },
+    },
+]
+
+
+def _ok(rid, result):
+    return {"jsonrpc": "2.0", "id": rid, "result": result}
+
+
+def _err(rid, code, msg):
+    return {"jsonrpc": "2.0", "id": rid, "error": {"code": code, "message": msg}}
+
+
+def _text(obj):
+    """도구 결과는 텍스트 콘텐츠로 돌려준다. 에이전트가 JSON을 잘 읽으므로
+    구조를 그대로 직렬화하되, 사람이 로그를 볼 때도 읽히게 들여쓴다."""
+    return {"content": [{"type": "text",
+                         "text": json.dumps(obj, ensure_ascii=False, indent=1)}]}
+
+
+def tools(lang="ko"):
+    """도구 목록. 설명이 언어를 탄다 — 에이전트는 이 설명을 읽고 판단한다."""
+    out = []
+    for t in TOOLS:
+        d = dict(t)
+        d["description"] = I.t(I.TOOLDESC.get(t["name"], t["description"]), lang)
+        out.append(d)
+    return out
+
+
+def handle(body: Dict[str, Any], call, lang: str = "ko") -> Any:
+    """call(name, args) -> dict 를 받아 도구를 실제로 실행한다.
+
+    반환이 None 이면 응답 없음(notification)이라는 뜻이다.
+    """
+    method = body.get("method")
+    rid = body.get("id")
+
+    if method == "initialize":
+        return _ok(rid, {
+            "protocolVersion": PROTOCOL,
+            "capabilities": {"tools": {"listChanged": False}},
+            "serverInfo": SERVER,
+            "instructions": I.t(I.MCP_INSTRUCTIONS, lang),
+        })
+
+    if method and method.startswith("notifications/"):
+        return None                      # 알림은 응답하지 않는다
+
+    if method == "tools/list":
+        return _ok(rid, {"tools": tools(lang)})
+
+    if method == "tools/call":
+        p = body.get("params") or {}
+        name = p.get("name")
+        args = p.get("arguments") or {}
+        if not any(t["name"] == name for t in TOOLS):
+            return _err(rid, -32602, "알 수 없는 도구: %s" % name)
+        try:
+            return _ok(rid, _text(call(name, args)))
+        except PermissionError as e:
+            return _ok(rid, {"content": [{"type": "text", "text": str(e)}],
+                             "isError": True})
+        except Exception as e:
+            return _ok(rid, {"content": [
+                {"type": "text", "text": "%s: %s" % (type(e).__name__, e)}],
+                "isError": True})
+
+    if method == "ping":
+        return _ok(rid, {})
+
+    return _err(rid, -32601, "지원하지 않는 메서드: %s" % method)

app/static/index.html

@@ -3,10 +3,11 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1">
-<title>FINCHAL · 파이낸셜 예측 챌린지</title>
+<title>FINCHAL — AI vs Human Market Prediction Challenge</title>
+<meta name="description" content="A live 122-day forecasting contest with $2,000 in prizes. AI agents, quants and humans submit positions on NVIDIA, Bitcoin, Gold and Crude Oil and are ranked by real returns.">
 <script src="https://unpkg.com/lightweight-charts@4.1.3/dist/lightweight-charts.standalone.production.js"></script>
 <style>
-/* ORACLE 화면과 같은 밝은 팔레트. 어두운 배경에서 수익률 색이 안 읽혔다. */
+/* 밝은 팔레트. 어두운 배경에서는 수익률 색이 안 읽혔다. */
 :root{
  --bg:#f5f6f8; --panel:#ffffff; --panel2:#f4f6f9; --line:#e4e8ee;
  --tx:#0f1729; --dim:#5f6b7f; --faint:#6b7684;
@@ -24,13 +25,23 @@ a{color:var(--acc);text-decoration:none}
 .card{background:var(--panel);border:1px solid var(--line);border-radius:14px;
  padding:20px 22px;box-shadow:var(--sh)}
 h2{font-size:17px;margin:0 0 14px;letter-spacing:-.01em}
-h3{font-size:14px;margin:0 0 8px;color:var(--dim);font-weight:600}
 .mono{font-variant-numeric:tabular-nums;
  font-family:"SF Mono",ui-monospace,"Cascadia Mono",Consolas,monospace}
 .up{color:var(--up)} .dn{color:var(--dn)} .dim{color:var(--dim)} .faint{color:var(--faint)}
 
+/* ───── 상단 바 ───── */
+.top{display:flex;justify-content:flex-end;align-items:center;gap:8px;padding:14px 0 0}
+.lang{display:flex;border:1px solid var(--line);border-radius:9px;overflow:hidden;
+ background:var(--panel);box-shadow:var(--sh)}
+.lang button{border:0;background:transparent;padding:7px 13px;cursor:pointer;
+ font-weight:700;font-size:12px;color:var(--faint)}
+.lang button.on{background:var(--acc);color:#fff}
+.acct{display:flex;align-items:center;gap:8px;background:var(--panel);border:1px solid var(--line);
+ border-radius:9px;padding:5px 11px;box-shadow:var(--sh);font-size:12.5px;font-weight:600}
+.acct img{width:20px;height:20px;border-radius:50%}
+
 /* ───── 히어로 ───── */
-.hero{padding:52px 0 28px;text-align:center}
+.hero{padding:34px 0 28px;text-align:center}
 .kicker{display:inline-block;background:var(--acc-bg);color:var(--acc);font-weight:700;
  font-size:12px;letter-spacing:.06em;padding:6px 14px;border-radius:999px}
 .hero h1{font-size:clamp(30px,5vw,50px);margin:16px 0 6px;letter-spacing:-.03em;line-height:1.14}
@@ -42,7 +53,7 @@ h3{font-size:14px;margin:0 0 8px;color:var(--dim);font-weight:600}
 .ctas{display:flex;gap:10px;justify-content:center;margin-top:24px;flex-wrap:wrap}
 .btn{border:1px solid var(--line);background:var(--panel);color:var(--tx);
  padding:11px 20px;border-radius:10px;font-weight:600;font-size:14px;cursor:pointer;
- box-shadow:var(--sh);transition:.12s}
+ box-shadow:var(--sh);transition:.12s;display:inline-block}
 .btn:hover{box-shadow:var(--sh2);transform:translateY(-1px)}
 .btn.pri{background:var(--acc);border-color:var(--acc);color:#fff}
 .btn:disabled{opacity:.5;cursor:not-allowed;transform:none}
@@ -63,15 +74,21 @@ h3{font-size:14px;margin:0 0 8px;color:var(--dim);font-weight:600}
 .row3{display:grid;grid-template-columns:repeat(3,1fr);gap:16px;margin-top:16px}
 @media(max-width:940px){.row3{grid-template-columns:1fr}}
 
-/* ───── 지표 ───── */
 .kpis{display:grid;grid-template-columns:repeat(4,1fr);gap:1px;background:var(--line);
  border:1px solid var(--line);border-radius:12px;overflow:hidden;margin-bottom:14px}
 .kpi{background:var(--panel);padding:14px 16px}
-.kpi .l{font-size:11px;color:var(--faint);letter-spacing:.02em}
+.kpi .l{font-size:11px;color:var(--faint)}
 .kpi .v{font-size:21px;font-weight:700;letter-spacing:-.02em;margin-top:3px}
 @media(max-width:700px){.kpis{grid-template-columns:repeat(2,1fr)}}
 
 #chart{height:clamp(380px,calc(100vh - 340px),620px)}
+/* TradingView 위젯. 실제 시세는 TV가, 참가자 수익률 곡선은 우리가 그린다. */
+.tape{margin:14px 0 0;border:1px solid var(--line);border-radius:12px;overflow:hidden;
+ background:var(--panel);box-shadow:var(--sh)}
+#tvchart{height:clamp(360px,52vh,520px)}
+#tvta{height:420px}
+#tvprofile{height:290px}
+.tvnote{font-size:11px;color:var(--faint);text-align:right;padding:6px 4px 0}
 .legend{display:flex;flex-wrap:wrap;gap:6px 14px;margin-top:12px;font-size:12px}
 .legend i{width:16px;height:3px;border-radius:2px;display:inline-block;
  vertical-align:middle;margin-right:6px}
@@ -79,18 +96,18 @@ h3{font-size:14px;margin:0 0 8px;color:var(--dim);font-weight:600}
 /* ───── 표 ───── */
 .tw{overflow-x:auto;-webkit-overflow-scrolling:touch}
 table{width:100%;border-collapse:collapse;font-size:13px}
-/* 좁은 화면에서 8열이 짓눌리면 숫자를 못 읽는다. 줄이지 말고 밀어서 보게 한다. */
-.tw table{min-width:660px}
+.tw table{min-width:660px}   /* 좁은 화면에서 짓눌리면 숫자를 못 읽는다 */
 th{text-align:left;font-size:11px;color:var(--faint);font-weight:600;
- padding:0 10px 9px;letter-spacing:.03em;border-bottom:1px solid var(--line)}
+ padding:0 10px 9px;border-bottom:1px solid var(--line)}
 td{padding:11px 10px;border-bottom:1px solid var(--line)}
 tr:last-child td{border-bottom:0}
 tbody tr:hover{background:var(--panel2)}
+tbody tr.mine{background:var(--acc-bg)}
 .num{text-align:right}
 .rk{width:34px;font-weight:700;color:var(--faint)}
 .rk.g{color:var(--gold)}
-.who b{font-weight:600}
-.who small{display:block;color:var(--faint);font-size:11px;margin-top:1px}
+.nm b{font-weight:600}
+.nm small{display:block;color:var(--faint);font-size:11px;margin-top:1px}
 .pill{display:inline-block;font-size:10px;padding:2px 7px;border-radius:6px;
  background:var(--panel2);color:var(--dim);border:1px solid var(--line);font-weight:600}
 .pill.base{background:#f2f0fb;color:#5b4bb5;border-color:#e3ddf6}
@@ -101,15 +118,22 @@ tbody tr:hover{background:var(--panel2)}
 .sub input[type=text]{width:100%;padding:9px 11px;border:1px solid var(--line);
  border-radius:9px;background:var(--panel2);color:var(--tx);font-size:13px}
 .sub input[type=range]{width:100%;accent-color:var(--acc)}
-.posv{font-size:30px;font-weight:700;text-align:center;letter-spacing:-.02em;margin:6px 0}
-.posl{text-align:center;font-size:12px;color:var(--faint);margin-bottom:6px}
+.posv{font-size:32px;font-weight:700;text-align:center;letter-spacing:-.02em;margin:4px 0}
+.posl{text-align:center;font-size:12px;color:var(--faint);margin-bottom:10px;min-height:34px}
+.side{display:grid;grid-template-columns:repeat(3,1fr);gap:6px;margin-bottom:12px}
+.side button{border:1px solid var(--line);background:var(--panel);border-radius:9px;
+ padding:9px 0;font-weight:700;font-size:12.5px;cursor:pointer;color:var(--dim)}
+.side button.on[data-s="1"]{background:var(--up-bg);border-color:#a8ddc4;color:var(--up)}
+.side button.on[data-s="0"]{background:var(--panel2);border-color:#c9d2de;color:var(--tx)}
+.side button.on[data-s="-1"]{background:var(--dn-bg);border-color:#f4b8b2;color:var(--dn)}
 .marks{display:flex;justify-content:space-between;font-size:10px;color:var(--faint)}
 .note{background:var(--panel2);border-radius:9px;padding:10px 12px;font-size:12px;
  color:var(--dim);margin-top:12px;line-height:1.55}
+.note.bad{background:var(--dn-bg);color:var(--dn)}
 .key{background:var(--up-bg);border:1px solid #bfe5d3;border-radius:9px;padding:10px 12px;
  font-size:12px;margin-top:12px;word-break:break-all}
 
-/* ───── 규칙·프롬프트 ───── */
+/* ───── 설명 ───── */
 pre{background:#0f1729;color:#e6edf7;border-radius:11px;padding:14px 16px;overflow:auto;
  font-size:12px;line-height:1.65;margin:0;
  font-family:"SF Mono",ui-monospace,Consolas,monospace}
@@ -119,6 +143,27 @@ pre{background:#0f1729;color:#e6edf7;border-radius:11px;padding:14px 16px;overfl
 .why div{background:var(--panel2);border-radius:10px;padding:12px 14px}
 .why b{display:block;margin-bottom:3px}
 .why span{font-size:12.5px;color:var(--dim)}
+.acts{display:grid;grid-template-columns:repeat(3,1fr);gap:18px}
+@media(max-width:880px){.acts{grid-template-columns:1fr}}
+.act{position:relative;padding-top:6px}
+.act em{display:block;font-style:normal;font-size:11px;font-weight:800;letter-spacing:.09em;
+ color:var(--acc);margin-bottom:7px}
+.act b{display:block;font-size:16.5px;letter-spacing:-.015em;margin-bottom:8px;line-height:1.3}
+.act p{margin:0;font-size:13.5px;color:var(--dim);line-height:1.72}
+.creed{margin-top:20px;padding-top:16px;border-top:1px solid var(--line);
+ text-align:center;font-size:14.5px;color:var(--tx);font-weight:600;letter-spacing:-.01em}
+.steps{display:grid;grid-template-columns:repeat(4,1fr);gap:12px}
+@media(max-width:860px){.steps{grid-template-columns:1fr 1fr}}
+.step{background:var(--panel2);border-radius:11px;padding:14px 15px}
+.step i{display:inline-flex;width:24px;height:24px;border-radius:7px;background:var(--acc);
+ color:#fff;font-style:normal;font-weight:700;font-size:12px;align-items:center;
+ justify-content:center;margin-bottom:8px}
+.step b{display:block;margin-bottom:3px;font-size:13.5px}
+.step span{font-size:12.5px;color:var(--dim)}
+.ex{margin-top:14px;border:1px solid var(--line);border-radius:11px;overflow:auto}
+.ex table{min-width:0;font-size:12.5px}
+.ex th{padding:9px 12px;background:var(--panel2);border-bottom:1px solid var(--line)}
+.ex td{padding:9px 12px}
 .foot{margin-top:34px;padding-top:18px;border-top:1px solid var(--line);
  color:var(--faint);font-size:12px;text-align:center}
 .load{padding:40px;text-align:center;color:var(--faint)}
@@ -127,24 +172,53 @@ pre{background:#0f1729;color:#e6edf7;border-radius:11px;padding:14px 16px;overfl
 <body>
 <div class="wrap">
 
-  <!-- ① 취지 -->
+  <div class="top">
+    <div id="acct"></div>
+    <div class="lang">
+      <button id="lk" onclick="setLang('ko')">한국어</button>
+      <button id="le" onclick="setLang('en')">EN</button>
+    </div>
+  </div>
+
   <div class="hero">
     <span class="kicker">FINANCIAL FORECAST CHALLENGE · SEASON 1</span>
-    <h1 id="m-title">AI는 시장을 이길 수 있는가</h1>
-    <div class="sub" id="m-sub">122일간의 공개 실험</div>
-    <div class="prize"><span class="dim">총 상금</span><b>$2,000</b>
-      <span class="dim" id="prize-rule">종목별 1위 $500 × 4종목</span></div>
+    <h1 id="m-title">—</h1>
+    <div class="sub" id="m-sub">—</div>
+    <div class="prize"><span class="dim" id="t-prize">—</span><b>$2,000</b>
+      <span class="dim" id="prize-rule">—</span></div>
     <div class="meta" id="m-meta">—</div>
     <div class="ctas">
-      <button class="btn pri" onclick="go('#submit')">직접 참가하기</button>
-      <button class="btn" onclick="go('#guide')">에이전트로 참가하기</button>
+      <button class="btn pri" id="cta1" onclick="go('#submit')">—</button>
+      <button class="btn" id="cta2" onclick="go('#guide')">—</button>
     </div>
   </div>
 
-  <!-- 종목 탭 -->
+  <div class="card" id="manifesto" style="margin-bottom:16px">
+    <div class="acts" id="acts"></div>
+    <div class="creed" id="creed">—</div>
+  </div>
+
+  <div class="card" id="howto">
+    <h2 id="t-howto">—</h2>
+    <div class="steps" id="steps"></div>
+    <div class="ex"><table><thead><tr>
+      <th id="t-ex1">—</th><th id="t-ex2">—</th>
+      <th class="num" id="t-ex3">—</th><th class="num" id="t-ex4">—</th>
+    </tr></thead><tbody id="exrows"></tbody></table></div>
+    <div class="note" id="ex-note">—</div>
+  </div>
+
+  <div class="tape" id="tape"></div>
+
   <div class="tabs" id="tabs"></div>
 
-  <!-- ② 차트 + ④ 제출 -->
+  <div class="card" style="margin-bottom:16px">
+    <h2><span id="t-tv">—</span>
+      <span class="faint" style="font-weight:400;font-size:13px" id="tv-sub"></span></h2>
+    <div id="tvchart"></div>
+    <div class="tvnote">Charts by TradingView</div>
+  </div>
+
   <div class="grid">
     <div class="card">
       <div class="kpis" id="kpis"></div>
@@ -154,283 +228,609 @@ pre{background:#0f1729;color:#e6edf7;border-radius:11px;padding:14px 16px;overfl
 
     <div>
       <div class="card sub" id="submit">
-        <h2>포지션 제출</h2>
+        <h2 id="t-submit">—</h2>
+        <div class="side">
+          <button data-s="1"  onclick="setSide(1)"  id="sb1">—</button>
+          <button data-s="0"  onclick="setSide(0)"  id="sb0">—</button>
+          <button data-s="-1" onclick="setSide(-1)" id="sbm1">—</button>
+        </div>
         <div class="posv mono" id="pv">+1.00</div>
-        <div class="posl" id="pl">전량 롱</div>
+        <div class="posl" id="pl">—</div>
         <input type="range" id="pos" min="-100" max="100" value="100" step="5"
                oninput="onPos()">
-        <div class="marks"><span>−1.0 숏</span><span>0 관망</span><span>+1.0 롱</span></div>
-
-        <label>참가 ID</label>
-        <input type="text" id="uid" placeholder="huggingface 아이디">
-        <label>전략명</label>
-        <input type="text" id="strat" placeholder="예: 20일 추세추종">
+        <div class="marks"><span id="t-mkS">—</span><span id="t-mkF">—</span>
+          <span id="t-mkL">—</span></div>
+        <div id="idbox"></div>
+        <label id="t-strat">—</label>
+        <input type="text" id="strat" placeholder="">
         <button class="btn pri" style="width:100%;margin-top:14px" id="go"
-                onclick="submit()">제출</button>
+                onclick="submit()">—</button>
         <div id="msg"></div>
-        <div class="note">
-          제출하면 <b>다시 낼 때까지</b> 이 포지션이 유지됩니다.
-          바꿀 때마다 수수료가 나가므로 자주 뒤집으면 손해입니다.
-        </div>
+        <div class="note" id="t-subnote">—</div>
+      </div>
+
+      <div class="card" style="margin-top:16px">
+        <h2 id="t-ta">—</h2>
+        <div id="tvta"></div>
+        <div class="note" id="t-tanote">—</div>
       </div>
 
       <div class="card" style="margin-top:16px">
-        <h2>운의 한계선</h2>
+        <h2 id="t-luck">—</h2>
         <div id="luck"></div>
         <div class="note" id="luck-note">—</div>
       </div>
     </div>
   </div>
 
-  <!-- ③ 랭킹 -->
   <div class="card" style="margin-top:16px">
-    <h2>순위 <span class="faint" style="font-weight:400;font-size:13px"
-      id="rk-sub"></span></h2>
+    <h2><span id="t-rank">—</span>
+      <span class="faint" style="font-weight:400;font-size:13px" id="rk-sub"></span></h2>
     <div class="tw"><table>
       <thead><tr>
-        <th class="rk">#</th><th>참가자 / 전략</th><th>유형</th>
-        <th class="num">수익률</th><th class="num">운 대비</th>
-        <th class="num">회전</th><th class="num">수수료</th><th class="num">참가일</th>
-      </tr></thead>
-      <tbody id="rank"><tr><td colspan="8" class="load">불러오는 중…</td></tr></tbody>
+        <th class="rk">#</th><th id="th-who">—</th><th id="th-type">—</th>
+        <th class="num" id="th-ret">—</th><th class="num" id="th-luck">—</th>
+        <th class="num" id="th-turn">—</th><th class="num" id="th-fee">—</th>
+        <th class="num" id="th-join">—</th>
+      </tr></thead><tbody id="rank"><tr><td colspan="8" class="load">…</td></tr></tbody>
     </table></div>
   </div>
 
-  <!-- 규칙 · 가이드 -->
   <div class="row3" id="guide">
-    <div class="card">
-      <h2>왜 하는가</h2>
-      <div class="why" id="why"></div>
-    </div>
-    <div class="card">
-      <h2>어떻게 다른가</h2>
-      <div class="why" id="how"></div>
-    </div>
-    <div class="card">
-      <h2>규칙</h2>
-      <div class="why" id="rules"></div>
-    </div>
+    <div class="card"><h2 id="t-why">—</h2><div class="why" id="why"></div></div>
+    <div class="card"><h2 id="t-how">—</h2><div class="why" id="how"></div></div>
+    <div class="card"><h2 id="t-rules">—</h2><div class="why" id="rules"></div></div>
   </div>
 
   <div class="card" style="margin-top:16px">
-    <h2>에이전트로 참가하기
-      <button class="copy" onclick="copyP()">복사</button></h2>
-    <p class="dim" style="margin:0 0 12px;font-size:13px">
-      Claude Code·Codex 등에 MCP 서버를 붙이면 도구 네 개가 생깁니다.
-      아래를 그대로 붙여넣으십시오.</p>
+    <h2><span id="t-agent">—</span>
+      <button class="copy" onclick="copyP()" id="t-copy">—</button></h2>
+    <p class="dim" style="margin:0 0 12px;font-size:13px" id="t-agentp">—</p>
     <pre id="prompt">—</pre>
   </div>
 
-  <div class="foot">
-    <span id="stake">—</span><br>
-    <span id="s2">—</span>
-  </div>
+  <div class="foot"><span id="stake">—</span><br><span id="s2">—</span></div>
 </div>
 
 <script>
-/* 차트 설정에는 CSS 변수를 넣을 수 없다. 문자열 그대로 들어가 무색이 된다. */
-const C = {
-  up:'#07804e', dn:'#c62828', line:'#e4e8ee', tx:'#0f1729', dim:'#6b7684',
-  pal:['#1f5fd6','#07804e','#c62828','#9a6b00','#7b4bb5','#0d8a9e',
-       '#d1640a','#4a5568','#b5297a','#2f7d32','#5b6ab5','#8a6d3b']
-};
-let R=null, ASSET=null, chart=null, lines=[];
-
-const fmt = v => (v>=0?'+':'') + v.toFixed(2) + '%';
-const go = h => document.querySelector(h).scrollIntoView({behavior:'smooth',block:'center'});
-const cls = v => v>0?'up':(v<0?'dn':'dim');
+/* 차트 설정에 CSS 변수를 넣으면 문자열 그대로 들어가 무색이 된다. */
+var C = {line:"#e4e8ee", dim:"#6b7684",
+  pal:["#1f5fd6","#07804e","#c62828","#9a6b00","#7b4bb5","#0d8a9e",
+       "#d1640a","#4a5568","#b5297a","#2f7d32","#5b6ab5","#8a6d3b"]};
+
+/* 화면 자체의 문구. 서버가 내려주는 문장(취지·규칙·힌트)은 API가 언어를 맞춰 준다. */
+var S = {
+ ko:{
+  prize:"총 상금", prizeRule:function(a){ return "종목별 1위 $500 × " + a + "종목"; },
+  meta:function(o,c,d){ return o + " ~ " + c + " · " + d + "일 · 레버리지 1 고정 · 매시간 갱신 가능"; },
+  cta1:"직접 참가하기", cta2:"에이전트로 참가하기",
+  howto:"어떻게 작동하나",
+  steps:[["참가","Hugging Face로 로그인하면 참가 ID와 키가 바로 발급됩니다."],
+         ["포지션","−1.0(전량 숏) ~ +1.0(전량 롱) 사이 숫자 하나를 냅니다. 0은 관망입니다."],
+         ["유지","다시 낼 때까지 그 포지션이 유지됩니다. 매일 들어올 필요가 없습니다."],
+         ["정산","청산 버튼은 없습니다. 값을 바꾸는 순간이 곧 청산이고 자동 계산됩니다."]],
+  ex1:"시점", ex2:"내 포지션", ex3:"시장", ex4:"내 수익",
+  exrows:[["월","+1.00 (전량 롱)","+3.0%","+3.0%"],
+          ["화","그대로 둠","−1.0%","−1.0%"],
+          ["수","0으로 변경 = 청산","+2.0%","0.0%"],
+          ["목","−1.00 (전량 숏)","−4.0%","+4.0%"]],
+  exNote:"수수료는 <b>바꾼 만큼</b>만 나갑니다. 비트코인에서 +1.0을 −1.0으로 뒤집으면 " +
+         "변경분이 2.0이라 0.12%가 빠집니다. 그대로 두면 한 푼도 안 나갑니다.",
+  submit:"포지션 제출", side:["롱","관망","숏"],
+  mkS:"−1.0 숏", mkF:"0 관망", mkL:"+1.0 롱",
+  posLong:function(v){ return "롱 " + v + "% — 오르면 법니다"; },
+  posShort:function(v){ return "숏 " + v + "% — 내리면 법니다"; },
+  posFlat:"관망 — 시장에 노출되지 않습니다. 들고 있던 포지션은 여기서 청산됩니다.",
+  strat:"전략명 (순위표에 표시됩니다)", stratPh:"예: 20일 추세추종",
+  go:"제출", goBusy:"제출 중…",
+  subNote:"제출하면 <b>다시 낼 때까지</b> 이 포지션이 유지됩니다. " +
+          "바꿀 때마다 수수료가 나가므로 자주 뒤집으면 손해입니다.",
+  signin:"Hugging Face로 로그인", signout:"로그아웃",
+  needLogin:"제출하려면 Hugging Face 로그인이 필요합니다.",
+  idAs:"참가 ID", keyIs:"참가키 (에이전트 연결에 씁니다)",
+  accepted:function(a,p){ return "접수됐습니다. " + a + " 포지션 " + p; },
+  luck:"운의 한계선", rank:"순위",
+  th:["참가자 / 전략","유형","수익률","운 대비","회전","수수료","참가일"],
+  kpi:["참가자","현재 1위","시장","운의 한계선"],
+  people:function(n){ return n + "명"; },
+  market:function(l){ return l + " 시장 (단순 보유)"; }, over:"★ 넘음",
+  noRows:"아직 참가자가 없습니다. 첫 번째가 되십시오.",
+  noCurve:"아직 곡선이 없습니다. 시즌이 하루 이상 진행되면 그려집니다.",
+  why:"왜 하는가", how:"어떻게 다른가", rules:"규칙",
+  rulesK:["포지션","갱신","수수료","순위","참여 요건"],
+  agent:"에이전트로 참가하기", copy:"복사",
+  agentP:"Claude Code·Codex 등에 MCP 서버를 붙이면 도구 네 개가 생깁니다. " +
+         "아래를 그대로 붙여넣으십시오.",
+  creed:"이 대회는 답을 모으지 않습니다. 경계를 잽니다.",
+  tv:"실시간 시세", tvSub:"TradingView 제공 · 채점에 쓰는 것과 같은 종목",
+  ta:"기술적 지표 요약",
+  taNote:"참고용입니다. 이 신호를 그대로 따르는 것이 이기는 방법이라는 근거는 없습니다 — " +
+         "그게 통했다면 이 대회를 열 이유가 없습니다."
+ },
+ en:{
+  prize:"Total prize", prizeRule:function(a){ return "$500 to each of " + a + " assets"; },
+  meta:function(o,c,d){ return o + " to " + c + " · " + d + " days · leverage fixed at 1 · update hourly"; },
+  cta1:"Enter yourself", cta2:"Enter an agent",
+  howto:"How it works",
+  steps:[["Join","Sign in with Hugging Face and your entrant ID and key are issued at once."],
+         ["Position","Submit one number between −1.0 (fully short) and +1.0 (fully long). Zero is flat."],
+         ["It stands","That position holds until you replace it. You do not have to show up daily."],
+         ["Settlement","There is no close button. Changing the number is the close, and it is scored automatically."]],
+  ex1:"Day", ex2:"Your position", ex3:"Market", ex4:"Your return",
+  exrows:[["Mon","+1.00 (fully long)","+3.0%","+3.0%"],
+          ["Tue","left unchanged","−1.0%","−1.0%"],
+          ["Wed","set to 0 = closed","+2.0%","0.0%"],
+          ["Thu","−1.00 (fully short)","−4.0%","+4.0%"]],
+  exNote:"Fees are charged on <b>the change only</b>. Flipping +1.0 to −1.0 on Bitcoin " +
+         "moves 2.0, which costs 0.12%. Leaving it alone costs nothing.",
+  submit:"Submit a position", side:["Long","Flat","Short"],
+  mkS:"−1.0 short", mkF:"0 flat", mkL:"+1.0 long",
+  posLong:function(v){ return "Long " + v + "% — you gain when it rises"; },
+  posShort:function(v){ return "Short " + v + "% — you gain when it falls"; },
+  posFlat:"Flat — no exposure. Any position you held is closed here.",
+  strat:"Strategy name (shown on the board)", stratPh:"e.g. 20-day trend following",
+  go:"Submit", goBusy:"Submitting…",
+  subNote:"Once submitted, this position <b>stands until you replace it</b>. " +
+          "Every change costs a fee, so flipping often loses money.",
+  signin:"Sign in with Hugging Face", signout:"Sign out",
+  needLogin:"Sign in with Hugging Face to submit.",
+  idAs:"Entrant", keyIs:"Your key (use it to connect an agent)",
+  accepted:function(a,p){ return "Recorded. " + a + " position " + p; },
+  luck:"Luck ceiling", rank:"Standings",
+  th:["Entrant / strategy","Type","Return","vs luck","Turnover","Fees","Joined"],
+  kpi:["Entrants","Leader","market","Luck ceiling"],
+  people:function(n){ return String(n); },
+  market:function(l){ return l + " market (buy and hold)"; }, over:"★ cleared",
+  noRows:"No entrants yet. Be the first.",
+  noCurve:"No curves yet. They appear once the season has run for a day.",
+  why:"Why this exists", how:"What is different", rules:"Rules",
+  rulesK:["Position","Updates","Fees","Ranking","Eligibility"],
+  agent:"Enter with an agent", copy:"Copy",
+  agentP:"Attach the MCP server to Claude Code, Codex or any agent and it gains four tools. " +
+         "Paste the block below.",
+  creed:"This contest does not collect answers. It measures the boundary.",
+  tv:"Live market", tvSub:"By TradingView · the same instrument we score",
+  ta:"Technical summary",
+  taNote:"Shown for reference. There is no evidence that following these signals wins — " +
+         "if it did, there would be no reason to run this contest."
+ }};
+
+/* TradingView 심볼. 우리 시세 소스(ETF)와 같은 것을 보여야 한다 —
+   금을 GLD로 채점하면서 화면에 XAUUSD를 띄우면 숫자가 안 맞는다. */
+var TV = {NVDA:"NASDAQ:NVDA", BTC:"BITSTAMP:BTCUSD", GOLD:"AMEX:GLD", OIL:"AMEX:USO"};
+
+/* 위젯은 컨테이너에 script 를 넣으면 그 자리에 그려진다. 다시 그릴 때는
+   컨테이너를 통째로 비워야 한다 — 안 그러면 위젯이 겹쳐 쌓인다. */
+function tvWidget(elId, src, cfg){
+  var el = document.getElementById(elId);
+  if (!el) return;
+  el.innerHTML = "";
+  var box = document.createElement("div");
+  box.className = "tradingview-widget-container";
+  box.style.height = "100%";
+  var inner = document.createElement("div");
+  inner.className = "tradingview-widget-container__widget";
+  inner.style.height = "100%";
+  box.appendChild(inner);
+  var sc = document.createElement("script");
+  sc.type = "text/javascript";
+  sc.async = true;
+  sc.src = "https://s3.tradingview.com/external-embedding/embed-widget-" + src + ".js";
+  sc.text = JSON.stringify(cfg);
+  box.appendChild(sc);
+  el.appendChild(box);
+}
+
+function tvLocale(){ return LANG === "ko" ? "kr" : "en"; }
+
+function drawTape(){
+  tvWidget("tape", "ticker-tape", {
+    symbols: Object.keys(TV).map(function(k){
+      return {proName: TV[k], title: (R && R.assets[k] ? R.assets[k].label : k)};
+    }),
+    showSymbolLogo: true, isTransparent: false, displayMode: "adaptive",
+    colorTheme: "light", locale: tvLocale()});
+}
+
+function drawTV(a){
+  tvWidget("tvchart", "advanced-chart", {
+    autosize: true, symbol: TV[a], interval: "D", timezone: "Asia/Seoul",
+    theme: "light", style: "1", locale: tvLocale(),
+    enable_publishing: false, allow_symbol_change: false,
+    hide_side_toolbar: false, withdateranges: true,
+    support_host: "https://www.tradingview.com"});
+  tvWidget("tvta", "technical-analysis", {
+    interval: "1D", width: "100%", height: 400, symbol: TV[a],
+    showIntervalTabs: true, displayMode: "single",
+    locale: tvLocale(), colorTheme: "light", isTransparent: false});
+}
+
+var LANG = "ko", R = null, MAN = null, ME = null, ASSET = null, chart = null;
+function L(){ return S[LANG]; }
+/* 막 번호. 숫자만 두면 목록으로 읽히고, 이름을 붙이면 논지로 읽힌다. */
+function ko1(i){
+  var ko = ["제1막","제2막","제3막"], en = ["ACT ONE","ACT TWO","ACT THREE"];
+  return (LANG === "ko" ? ko : en)[i] || "";
+}
+function fmt(v){ return (v >= 0 ? "+" : "") + v.toFixed(2) + "%"; }
+function cls(v){ return v > 0 ? "up" : (v < 0 ? "dn" : "dim"); }
+function go(h){ document.querySelector(h).scrollIntoView({behavior:"smooth", block:"center"}); }
+function $(id){ return document.getElementById(id); }
+
+async function setLang(l){
+  LANG = l;
+  document.documentElement.lang = l;
+  try { await fetch("/api/lang/" + l); } catch (e) {}
+  $("lk").className = l === "ko" ? "on" : "";
+  $("le").className = l === "en" ? "on" : "";
+  await boot();
+}
 
 async function boot(){
-  R = await (await fetch('/api/rules')).json();
-  document.getElementById('m-meta').textContent =
-    `${R.opens} ~ ${R.closes} · ${R.days}일 · 레버리지 1 고정 · 매시간 갱신`;
-  document.getElementById('prize-rule').textContent =
-    `종목별 1위 $500 × ${Object.keys(R.assets).length}종목`;
-  document.getElementById('luck-note').textContent = R.luck_note;
-
-  document.getElementById('tabs').innerHTML = Object.entries(R.assets).map(([k,v]) =>
-    `<div class="tab" data-a="${k}" onclick="pick('${k}')">
-       <span>${v.label}</span><span class="p">${k}</span></div>`).join('');
-
-  document.getElementById('luck').innerHTML = Object.entries(R.luck_ceiling)
-    .sort((a,b)=>b[1]-a[1]).map(([k,v]) =>
-    `<div style="display:flex;justify-content:space-between;padding:7px 0;
-       border-bottom:1px solid var(--line)">
-       <span>${R.assets[k].label}</span>
-       <b class="mono up">+${(v*100).toFixed(1)}%</b></div>`).join('');
-
-  const man = await (await fetch('/api/manifesto')).json();
-  document.getElementById('m-title').textContent = man.title;
-  document.getElementById('m-sub').textContent = man.sub;
-  const box = (a) => a.map(([t,d]) => `<div><b>${t}</b><span>${d}</span></div>`).join('');
-  document.getElementById('why').innerHTML = box(man.why);
-  document.getElementById('how').innerHTML = box(man.how);
-  document.getElementById('stake').textContent = man.our_stake;
-  document.getElementById('s2').textContent =
-    `${man.season2.name} — ${man.season2.teaser}. 종목은 시즌 1 종료 후 확정합니다.`;
-
-  document.getElementById('rules').innerHTML = box([
-    ['포지션', R.leverage],
-    ['갱신', R.update],
-    ['수수료', Object.entries(R.fees).map(([k,v])=>`${k} ${(v*100).toFixed(2)}%`).join(' · ')
-              + ' — ' + R.fee_note],
-    ['순위', R.scoring],
-    ['참여 요건', R.participation],
-  ]);
-
-  pick(Object.keys(R.assets)[0]);
+  R   = await (await fetch("/api/rules?lang=" + LANG)).json();
+  MAN = await (await fetch("/api/manifesto?lang=" + LANG)).json();
+  ME  = await (await fetch("/api/me")).json();
+  var s = L();
+
+  $("m-title").textContent = MAN.title;
+  $("m-sub").textContent   = MAN.sub;
+  $("t-prize").textContent = s.prize;
+  $("prize-rule").textContent = s.prizeRule(Object.keys(R.assets).length);
+  $("m-meta").textContent  = s.meta(R.opens, R.closes, R.days);
+  $("cta1").textContent    = s.cta1;
+  $("cta2").textContent    = s.cta2;
+
+  $("acts").innerHTML = (MAN.acts || []).map(function(x, i){
+    return '<div class="act"><em>' + (ko1(i)) + "</em><b>" + x[0] +
+           "</b><p>" + x[1] + "</p></div>"; }).join("");
+  $("creed").textContent = s.creed;
+
+  $("t-howto").textContent = s.howto;
+  $("steps").innerHTML = s.steps.map(function(x, i){
+    return '<div class="step"><i>' + (i + 1) + "</i><b>" + x[0] + "</b><span>" +
+           x[1] + "</span></div>"; }).join("");
+  ["ex1","ex2","ex3","ex4"].forEach(function(k){ $("t-" + k).textContent = s[k]; });
+  $("exrows").innerHTML = s.exrows.map(function(r){
+    return '<tr><td class="faint">' + r[0] + '</td><td class="mono">' + r[1] +
+      '</td><td class="num mono ' + cls(parseFloat(r[2])) + '">' + r[2] +
+      '</td><td class="num mono ' + cls(parseFloat(r[3])) + '"><b>' + r[3] +
+      "</b></td></tr>"; }).join("");
+  $("ex-note").innerHTML = s.exNote;
+
+  drawAcct();
+
+  $("t-submit").textContent = s.submit;
+  ["sb1","sb0","sbm1"].forEach(function(id, i){ $(id).textContent = s.side[i]; });
+  $("t-mkS").textContent = s.mkS;
+  $("t-mkF").textContent = s.mkF;
+  $("t-mkL").textContent = s.mkL;
+  $("t-strat").textContent = s.strat;
+  $("strat").placeholder = s.stratPh;
+  if (ME.strategy && !$("strat").value) $("strat").value = ME.strategy;
+  $("go").textContent = s.go;
+  $("t-subnote").innerHTML = s.subNote;
+
+  $("t-luck").textContent = s.luck;
+  $("luck-note").textContent = R.luck_note;
+  $("luck").innerHTML = Object.entries(R.luck_ceiling).sort(function(a, b){ return b[1] - a[1]; })
+    .map(function(e){
+      return '<div style="display:flex;justify-content:space-between;padding:7px 0;' +
+        'border-bottom:1px solid var(--line)"><span>' + R.assets[e[0]].label +
+        '</span><b class="mono up">+' + (e[1] * 100).toFixed(1) + "%</b></div>"; }).join("");
+
+  $("t-rank").textContent = s.rank;
+  ["th-who","th-type","th-ret","th-luck","th-turn","th-fee","th-join"]
+    .forEach(function(id, i){ $(id).textContent = s.th[i]; });
+
+  $("t-why").textContent = s.why;
+  $("t-how").textContent = s.how;
+  $("t-rules").textContent = s.rules;
+  var box = function(a){
+    return a.map(function(x){
+      return "<div><b>" + x[0] + "</b><span>" + x[1] + "</span></div>"; }).join(""); };
+  $("why").innerHTML = box(MAN.why);
+  $("how").innerHTML = box(MAN.how);
+  $("rules").innerHTML = box([
+    [s.rulesK[0], R.leverage], [s.rulesK[1], R.update],
+    [s.rulesK[2], Object.entries(R.fees).map(function(e){
+        return e[0] + " " + (e[1] * 100).toFixed(2) + "%"; }).join(" · ") +
+      " — " + R.fee_note],
+    [s.rulesK[3], R.scoring], [s.rulesK[4], R.participation]]);
+
+  $("t-tv").textContent = s.tv;
+  $("tv-sub").textContent = s.tvSub;
+  $("t-ta").textContent = s.ta;
+  $("t-tanote").textContent = s.taNote;
+  drawTape();
+  $("t-agent").textContent = s.agent;
+  $("t-copy").textContent = s.copy;
+  $("t-agentp").textContent = s.agentP;
+  $("stake").textContent = MAN.our_stake;
+  $("s2").textContent = MAN.season2.name + " — " + MAN.season2.teaser + ". " +
+                        MAN.season2.note;
+
+  $("tabs").innerHTML = Object.entries(R.assets).map(function(e){
+    return '<div class="tab" data-a="' + e[0] + '" onclick="pick(\'' + e[0] + '\')">' +
+      "<span>" + e[1].label + '</span><span class="p">' + e[0] + "</span></div>"; }).join("");
+
+  onPos();
+  pick(ASSET && R.assets[ASSET] ? ASSET : Object.keys(R.assets)[0]);
 }
 
-function prompt_(a){
-  document.getElementById('prompt').textContent =
-`claude mcp add --transport http finchal ${location.origin}/mcp \\
-  --header "Authorization: Bearer <내 참가키>"
-
-# 그 다음 에이전트에게 이렇게 말하면 됩니다
-"finchal 챌린지에 참가해줘. get_rules로 규칙을 읽고,
- get_data로 ${a} 시세를 받아서 직접 모델을 만든 다음
- submit_position으로 포지션을 내줘. 매일 check_score로 성적을 확인하고
- 필요하면 포지션을 조정해."
-
-# 도구 넷
-get_rules()          규칙·종목·수수료·마감
-get_data(asset,bars) 과거 시세 (미래는 주지 않습니다)
-submit_position(asset, position)   -1.0 ~ +1.0
-check_score(asset)   내 순위와 운의 한계선 대비 위치`;
+function drawAcct(){
+  var s = L();
+  if (ME.signed_in) {
+    var u = ME.user;
+    $("acct").innerHTML = '<div class="acct">' +
+      (u.picture ? '<img src="' + u.picture + '" alt="">' : "") +
+      "<span>" + u.name + '</span><a href="/logout" class="faint" ' +
+      'style="font-size:11px">' + s.signout + "</a></div>";
+    $("idbox").innerHTML = '<div class="key"><span class="dim">' + s.idAs +
+      "</span> <b>" + u.name + '</b><br><span class="dim">' + s.keyIs +
+      '</span><br><b class="mono">' + ME.key + "</b></div>";
+  } else {
+    $("acct").innerHTML = ME.oauth_configured
+      ? '<a class="btn" href="/login">' + s.signin + "</a>" : "";
+    $("idbox").innerHTML = ME.oauth_configured
+      ? '<div class="note">' + s.needLogin + "</div>" : "";
+  }
 }
-function copyP(){
-  navigator.clipboard.writeText(document.getElementById('prompt').textContent);
+
+function prompt_(a){
+  /* 🔑 에이전트가 이 블록만 읽고 끝까지 갈 수 있어야 한다. 조건이 하나라도 빠지면
+     그 자리에서 멈추거나, 더 나쁘게는 틀린 가정으로 계속 간다.
+     실제로 일봉만 주면서 시간봉을 받은 것처럼 보이던 결함이 있었다. */
+  var key  = ME.key || (LANG === "ko" ? "<로그인하면 발급됩니다>" : "<sign in to get one>");
+  var ko   = LANG === "ko";
+  var lab  = R.assets[a].label;
+  var fee  = (R.fees[a] * 100).toFixed(2);
+  var flip = (R.fees[a] * 200).toFixed(2);
+  var ceil = (R.luck_ceiling[a] * 100).toFixed(1);
+  var BS   = String.fromCharCode(92);        // 셸 줄바꿈용 역슬래시
+
+  var head =
+    "# 1. " + (ko ? "MCP 서버 연결 — 터미널에 한 줄"
+                  : "Connect the MCP server — one line in your terminal") + "\n" +
+    "claude mcp add --transport http finchal " + location.origin + "/mcp " + BS + "\n" +
+    '  --header "X-Finchal-Key: ' + key + '"\n\n' +
+    "# " + (ko ? "Codex 등 다른 에이전트는 MCP 설정 파일에 같은 값을 넣으십시오."
+               : "For Codex or any other agent, put the same values in your MCP config.") + "\n" +
+    "#   url     " + location.origin + "/mcp\n" +
+    "#   header  X-Finchal-Key: " + key + "\n" +
+    "# " + (ko ? "Authorization 헤더도 받지만, 앞단 프록시가 그 헤더를 쓰는 환경에서는"
+               : "Authorization is accepted too, but where a proxy consumes that header") + "\n" +
+    "# " + (ko ? "키가 서버까지 오지 않습니다. X-Finchal-Key 를 쓰십시오."
+               : "the key never reaches us. Prefer X-Finchal-Key.") + "\n\n";
+
+  var briefKo =
+    "# 2. 에이전트에게 그대로 붙여넣을 지시문\n" +
+    '"""\n' +
+    "finchal 챌린지에 " + a + "(" + lab + ") 종목으로 참가해줘.\n\n" +
+    "규칙 — 어기면 성적이 무효가 되거나 손해를 본다\n" +
+    "  · 먼저 get_rules() 를 호출해라. 아래는 요약이고 원본은 그쪽이다.\n" +
+    "  · 포지션은 -1.0(전량 숏) ~ +1.0(전량 롱) 사이 실수 하나다. 0.35 같은 소수도 된다.\n" +
+    "    0 은 관망이며, 들고 있던 포지션을 0 으로 바꾸는 것이 곧 청산이다.\n" +
+    "  · 레버리지는 1 고정. 범위를 벗어나 내면 잘린다. 크게 걸어 이기는 길은 없다.\n" +
+    "  · 한 번 낸 포지션은 다시 낼 때까지 유지된다. 매시간 낼 필요가 없다.\n" +
+    "  · 수수료는 바꾼 만큼만 나간다. " + a + " 는 변경분 1.0당 " + fee + "% 다.\n" +
+    "    +1 에서 -1 로 뒤집으면 변경분이 2.0이라 " + flip + "% 가 빠진다.\n" +
+    "    매일 뒤집는 전략은 실측에서 수수료만 10% 넘게 냈다. 회전율을 먼저 계산해라.\n" +
+    "  · 시즌 기간의 70% 이상 유효한 포지션이 있어야 상금 대상이다.\n\n" +
+    "데이터\n" +
+    '  · get_data(asset="' + a + '", bars=1200) 로 과거 일봉 종가를 받아라.\n' +
+    "  · 일봉만 제공한다. interval 은 '1d' 뿐이고 다른 값은 거부된다.\n" +
+    "  · 미래 데이터는 없다. 정답은 네가 제출한 뒤에 세상이 만든다.\n" +
+    "  · 다른 종목도 받을 수 있다: NVDA · BTC · GOLD · OIL.\n" +
+    "    서로 상관이 낮아 한 종목을 다른 종목으로 설명하려는 시도는 대체로 실패한다.\n\n" +
+    "할 일\n" +
+    "  1) 데이터를 받아 직접 모델을 세워라. 규칙 기반이든 통계든 학습이든 상관없다.\n" +
+    "  2) 그 모델이 오늘 시사하는 포지션을 숫자 하나로 정하라.\n" +
+    '  3) submit_position(asset="' + a + '", position=<숫자>) 로 제출하라.\n' +
+    '  4) check_score(asset="' + a + '") 로 순위와 운의 한계선 대비 위치를 확인하라.\n' +
+    "     " + a + " 의 운의 한계선은 +" + ceil + "% 다. 실력 0인 참가자를 2만 번 돌려 나온\n" +
+    "     상위 5% 지점이고, 이 선을 넘지 못한 수익은 실력의 증거가 아니다.\n" +
+    "  5) 판단이 바뀔 때만 다시 제출하라. 바꿀 이유가 없으면 두는 편이 이득이다.\n\n" +
+    "시작 전에 이 둘을 먼저 확인해라\n" +
+    "  · 네 전략의 예상 회전율과 거기 붙는 수수료를 계산해라. 그 수수료가 기대수익을\n" +
+    "    넘으면 그 전략은 시작 전에 이미 진 것이다.\n" +
+    "  · 백테스트 성적을 근거로 삼기 전에, 같은 규칙을 무작위 포지션에 적용했을 때\n" +
+    "    나오는 분포와 비교해라. 차이가 없으면 성적이 아니라 잡음이다.\n" +
+    '"""\n';
+
+  var briefEn =
+    "# 2. Paste this to your agent verbatim\n" +
+    '"""\n' +
+    "Enter the finchal challenge on " + a + " (" + lab + ").\n\n" +
+    "Rules — breaking these voids your result or costs you money\n" +
+    "  - Call get_rules() first. What follows is a summary; that call is the source.\n" +
+    "  - A position is one real number from -1.0 (fully short) to +1.0 (fully long).\n" +
+    "    Fractions like 0.35 are fine. Zero is flat, and moving to zero is how you close.\n" +
+    "  - Leverage is fixed at 1. Values outside the range are clipped. Betting bigger\n" +
+    "    is not a way to win here.\n" +
+    "  - A submitted position stands until you replace it. You need not submit hourly.\n" +
+    "  - Fees are charged on the change. " + a + " costs " + fee + "% per 1.0 of change.\n" +
+    "    Flipping +1 to -1 moves 2.0 and costs " + flip + "%.\n" +
+    "    A daily-flip strategy paid over 10% in fees alone in our measurements.\n" +
+    "    Work out your turnover before you commit to a design.\n" +
+    "  - You need a valid position for 70% of the season to be eligible for the prize.\n\n" +
+    "Data\n" +
+    '  - get_data(asset="' + a + '", bars=1200) returns historical daily closes.\n' +
+    "  - Daily bars only. interval accepts '1d' and rejects anything else.\n" +
+    "  - There is no future data. The answer is created after you submit.\n" +
+    "  - Other assets are available: NVDA, BTC, GOLD, OIL. They are close to\n" +
+    "    uncorrelated, so explaining one with another usually fails.\n\n" +
+    "What to do\n" +
+    "  1) Pull the data and build your own model. Rules, statistics or learning —\n" +
+    "     it does not matter which.\n" +
+    "  2) Decide what position that model implies today, as a single number.\n" +
+    '  3) Submit it with submit_position(asset="' + a + '", position=<number>).\n' +
+    '  4) Use check_score(asset="' + a + '") for your rank and your distance from the\n' +
+    "     luck ceiling. For " + a + " that line is +" + ceil + "%: the 95th percentile of\n" +
+    "     20,000 zero-skill runs. A return below it is not evidence of skill.\n" +
+    "  5) Resubmit only when your judgement changes. Standing pat is often correct.\n\n" +
+    "Check these two before anything else\n" +
+    "  - Estimate your turnover and the fees it implies. If those fees exceed your\n" +
+    "    expected edge, the strategy has already lost before it starts.\n" +
+    "  - Before trusting a backtest, compare it against the distribution the same rules\n" +
+    "    produce on random positions. No gap means noise, not performance.\n" +
+    '"""\n';
+
+  var tools =
+    "\n# 3. " + (ko ? "도구 넷" : "The four tools") + "\n" +
+    "get_rules()                          " +
+      (ko ? "규칙 · 종목 · 수수료 · 마감 · 운의 한계선"
+          : "rules, assets, fees, deadline, luck ceiling") + "\n" +
+    "get_data(asset, bars, interval)      " +
+      (ko ? "과거 일봉 종가. 미래는 주지 않습니다"
+          : "historical daily closes. no future data") + "\n" +
+    "submit_position(asset, position)     -1.0 ~ +1.0\n" +
+    "check_score(asset)                   " +
+      (ko ? "순위 · 수익률 · 운의 한계선 대비 위치"
+          : "rank, return, distance from the luck ceiling");
+
+  $("prompt").textContent = head + (ko ? briefKo : briefEn) + tools;
 }
+function copyP(){ navigator.clipboard.writeText($("prompt").textContent); }
 
 async function pick(a){
   ASSET = a;
-  document.querySelectorAll('.tab').forEach(t =>
-    t.classList.toggle('on', t.dataset.a === a));
+  var tabs = document.querySelectorAll(".tab");
+  for (var i = 0; i < tabs.length; i++) {
+    tabs[i].classList.toggle("on", tabs[i].dataset.a === a);
+  }
   prompt_(a);
-  document.getElementById('rk-sub').textContent =
-    `${R.assets[a].label} · 1위 $500 · ${R.assets[a].why}`;
+  drawTV(a);
+  $("rk-sub").textContent = R.assets[a].label + " · $500 · " + R.assets[a].why;
   await Promise.all([drawChart(a), drawRank(a)]);
 }
 
 async function drawChart(a){
-  const d = await (await fetch(`/api/curves?asset=${a}&top=12`)).json();
-  const el = document.getElementById('chart');
-  if(chart){ chart.remove(); chart = null; }
+  var s = L();
+  var d = await (await fetch("/api/curves?asset=" + a + "&top=12")).json();
+  var el = $("chart");
+  if (chart) { chart.remove(); chart = null; }
   chart = LightweightCharts.createChart(el, {
-    layout:{background:{color:'#ffffff'}, textColor:C.dim, fontSize:11},
+    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,
-  });
-  const t = d.t.map(x => x.slice(0,10));
-  const mk = (name, vals, color, w, dash) => {
-    const s = chart.addLineSeries({color, lineWidth:w, lineStyle:dash?2:0,
+    crosshair:{mode:1}, height:el.clientHeight});
+  var t = d.t.map(function(x){ return x.slice(0, 10); });
+  var mk = function(vals, color, dash){
+    var ss = chart.addLineSeries({color:color, lineWidth:2, lineStyle:dash ? 2 : 0,
       priceLineVisible:false, lastValueVisible:false});
-    s.setData(t.map((x,i)=>({time:x, value:vals[i]})));
-    return s;
+    ss.setData(t.map(function(x, i){ return {time:x, value:vals[i]}; }));
   };
-  const leg = [];
-  if(d.market && d.market.length){
-    mk('시장', d.market, C.dim, 2, true);
-    leg.push([C.dim, `${R.assets[a].label} 시장 (단순 보유)`,
-              d.market[d.market.length-1]]);
+  var leg = [];
+  if (d.market && d.market.length) {
+    mk(d.market, C.dim, true);
+    leg.push([C.dim, s.market(R.assets[a].label), d.market[d.market.length - 1]]);
   }
-  (d.series||[]).forEach((s,i) => {
-    const col = C.pal[i % C.pal.length];
-    mk(s.user, s.v, col, 2, false);
-    leg.push([col, `${s.user} · ${s.strategy}`, s.v[s.v.length-1]]);
+  (d.series || []).forEach(function(x, i){
+    var col = C.pal[i % C.pal.length];
+    mk(x.v, col, false);
+    leg.push([col, x.user + " · " + x.strategy, x.v[x.v.length - 1]]);
   });
   chart.timeScale().fitContent();
-  document.getElementById('legend').innerHTML = leg.length
-    ? leg.map(([c,n,v]) => `<span><i style="background:${c}"></i>${n}
-        <b class="mono ${cls(v)}">${fmt(v)}</b></span>`).join('')
-    : '<span class="faint">아직 곡선이 없습니다. 시즌이 하루 이상 진행되면 그려집니다.</span>';
-
-  const rows = (d.series||[]);
-  const best = rows.length ? Math.max(...rows.map(s=>s.v[s.v.length-1])) : 0;
-  const mkt = d.market && d.market.length ? d.market[d.market.length-1] : 0;
-  const K = [
-    ['참가자', rows.length + '명', ''],
-    ['현재 1위', rows.length?fmt(best):'—', cls(best)],
-    [`${R.assets[a].label} 시장`, d.market&&d.market.length?fmt(mkt):'—', cls(mkt)],
-    ['운의 한계선', '+' + (R.luck_ceiling[a]*100).toFixed(1) + '%', 'dim'],
-  ];
-  document.getElementById('kpis').innerHTML = K.map(([l,v,c]) =>
-    `<div class="kpi"><div class="l">${l}</div>
-       <div class="v mono ${c}">${v}</div></div>`).join('');
+  $("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>";
+
+  var rows = d.series || [];
+  var best = rows.length ? Math.max.apply(null, rows.map(function(x){
+    return x.v[x.v.length - 1]; })) : 0;
+  var mkt = (d.market && d.market.length) ? d.market[d.market.length - 1] : 0;
+  var K = [[s.kpi[0], s.people(rows.length), ""],
+           [s.kpi[1], rows.length ? fmt(best) : "—", cls(best)],
+           [R.assets[a].label + " " + s.kpi[2],
+            (d.market && d.market.length) ? fmt(mkt) : "—", cls(mkt)],
+           [s.kpi[3], "+" + (R.luck_ceiling[a] * 100).toFixed(1) + "%", "dim"]];
+  $("kpis").innerHTML = K.map(function(x){
+    return '<div class="kpi"><div class="l">' + x[0] + '</div><div class="v mono ' +
+      x[2] + '">' + x[1] + "</div></div>"; }).join("");
 }
 
 async function drawRank(a){
-  const d = await (await fetch(`/api/leaderboard?asset=${a}`)).json();
-  const tb = document.getElementById('rank');
-  if(!d.rows || !d.rows.length){
-    tb.innerHTML = `<tr><td colspan="8" class="load">
-      아직 참가자가 없습니다. 첫 번째가 되십시오.</td></tr>`;
+  var s = L();
+  var d = await (await fetch("/api/leaderboard?asset=" + a)).json();
+  var tb = $("rank");
+  if (!d.rows || !d.rows.length) {
+    tb.innerHTML = '<tr><td colspan="8" class="load">' + s.noRows + "</td></tr>";
     return;
   }
-  const ceil = R.luck_ceiling[a];
-  const B = {human:'🧑 사람', expert:'📊 전문가', agent:'🤖 에이전트', anchor:'기준선'};
-  tb.innerHTML = d.rows.map(r => {
-    const over = r.ret > r.luck_p95;
-    return `<tr>
-      <td class="rk ${r.rank===1?'g':''}">${r.rank}</td>
-      <td class="who"><b>${r.user}</b><small>${r.strategy}</small></td>
-      <td><span class="pill ${r.type==='anchor'?'base':''}">${B[r.type]||r.type}</span></td>
-      <td class="num mono ${cls(r.ret*100)}"><b>${fmt(r.ret*100)}</b></td>
-      <td class="num mono">${over?'<span class="star">★ 넘음</span>'
-          :`<span class="faint">${(r.ret/Math.max(ceil,1e-9)*100).toFixed(0)}%</span>`}</td>
-      <td class="num mono faint">${r.turnover.toFixed(1)}</td>
-      <td class="num mono ${r.fee_paid>0.02?'dn':'faint'}">
-          −${(r.fee_paid*100).toFixed(2)}%</td>
-      <td class="num faint">${(r.joined||'').slice(5,10)}</td>
-    </tr>`;
-  }).join('');
+  var ceil = R.luck_ceiling[a];
+  var mine = ME.signed_in ? ME.user.name : null;
+  tb.innerHTML = d.rows.map(function(r){
+    var vs = r.ret > r.luck_p95
+      ? '<span class="star">' + s.over + "</span>"
+      : '<span class="faint">' +
+        (r.ret / Math.max(ceil, 1e-9) * 100).toFixed(0) + "%</span>";
+    return '<tr class="' + (r.user === mine ? "mine" : "") + '">' +
+      '<td class="rk ' + (r.rank === 1 ? "g" : "") + '">' + r.rank + "</td>" +
+      '<td class="nm"><b>' + r.user + "</b><small>" + r.strategy + "</small></td>" +
+      '<td><span class="pill ' + (r.type === "anchor" ? "base" : "") + '">' +
+        (R.types[r.type] || r.type) + "</span></td>" +
+      '<td class="num mono ' + cls(r.ret * 100) + '"><b>' + fmt(r.ret * 100) + "</b></td>" +
+      '<td class="num mono">' + vs + "</td>" +
+      '<td class="num mono faint">' + r.turnover.toFixed(1) + "</td>" +
+      '<td class="num mono ' + (r.fee_paid > 0.02 ? "dn" : "faint") + '">−' +
+        (r.fee_paid * 100).toFixed(2) + "%</td>" +
+      '<td class="num faint">' + (r.joined || "").slice(5, 10) + "</td></tr>";
+  }).join("");
 }
 
+function setSide(v){ $("pos").value = v * 100; onPos(); }
+
 function onPos(){
-  const v = +document.getElementById('pos').value / 100;
-  document.getElementById('pv').textContent = (v>=0?'+':'') + v.toFixed(2);
-  document.getElementById('pv').className = 'posv mono ' + cls(v);
-  document.getElementById('pl').textContent =
-    v === 0 ? '관망 — 시장에 노출되지 않습니다'
-    : v > 0 ? `롱 ${(v*100).toFixed(0)}% — 오르면 법니다`
-            : `숏 ${(-v*100).toFixed(0)}% — 내리면 법니다`;
+  var s = L();
+  var v = +$("pos").value / 100;
+  $("pv").textContent = (v >= 0 ? "+" : "") + v.toFixed(2);
+  $("pv").className = "posv mono " + cls(v);
+  $("pl").textContent = v === 0 ? s.posFlat
+    : (v > 0 ? s.posLong((v * 100).toFixed(0)) : s.posShort((-v * 100).toFixed(0)));
+  var on = v > 0 ? "1" : (v < 0 ? "-1" : "0");
+  var bs = document.querySelectorAll(".side button");
+  for (var i = 0; i < bs.length; i++) bs[i].classList.toggle("on", bs[i].dataset.s === on);
 }
 
 async function submit(){
-  const uid = document.getElementById('uid').value.trim();
-  const st = document.getElementById('strat').value.trim() || '-';
-  const msg = document.getElementById('msg');
-  if(!uid){ msg.innerHTML = '<div class="note dn">참가 ID를 입력하십시오.</div>'; return; }
-  const b = document.getElementById('go');
-  b.disabled = true; b.textContent = '제출 중…';
-  try{
-    const reg = await (await fetch('/api/register', {method:'POST',
-      headers:{'Content-Type':'application/json'},
-      body:JSON.stringify({user:uid, strategy:st, type:'human',
-                           assets:Object.keys(R.assets)})})).json();
-    const pos = +document.getElementById('pos').value / 100;
-    const r = await (await fetch('/api/submit', {method:'POST',
-      headers:{'Content-Type':'application/json',
-               'X-Finchal-Key': reg.key},   /* 앞단 프록시와 안 부딪히는 전용 헤더 */
-      body:JSON.stringify({asset:ASSET, position:pos, source:'web'})})).json();
-    if(!r.ok) throw new Error(r.error || '실패');
-    msg.innerHTML = `<div class="key"><b>접수됐습니다.</b>
-      ${R.assets[ASSET].label} 포지션 ${(pos>=0?'+':'')+pos.toFixed(2)}<br>
-      <span class="dim">참가키 (에이전트 연결에 씁니다) —</span><br>
-      <b class="mono">${reg.key}</b></div>`;
+  var s = L(), msg = $("msg");
+  if (ME.oauth_configured && !ME.signed_in) {
+    msg.innerHTML = '<div class="note bad">' + s.needLogin + "</div>";
+    return;
+  }
+  var b = $("go");
+  b.disabled = true; b.textContent = s.goBusy;
+  try {
+    var pos = +$("pos").value / 100;
+    var r = await (await fetch("/api/submit", {method:"POST",
+      headers:{"Content-Type":"application/json",
+               "X-Finchal-Key": ME.key || ""},   /* 프록시와 안 부딪히는 전용 헤더 */
+      body:JSON.stringify({asset:ASSET, position:pos, source:"web",
+        strategy:$("strat").value.trim() || "-", type:"human"})})).json();
+    if (!r.ok) throw new Error(r.error || "failed");
+    msg.innerHTML = '<div class="key"><b>' +
+      s.accepted(R.assets[ASSET].label, (pos >= 0 ? "+" : "") + pos.toFixed(2)) +
+      "</b></div>";
     drawRank(ASSET);
-  }catch(e){
-    msg.innerHTML = `<div class="note dn">${e.message}</div>`;
+  } catch (e) {
+    msg.innerHTML = '<div class="note bad">' + e.message + "</div>";
   }
-  b.disabled = false; b.textContent = '제출';
+  b.disabled = false; b.textContent = s.go;
 }
 
-addEventListener('resize', () => {
-  if(chart) chart.applyOptions({height:document.getElementById('chart').clientHeight});
+addEventListener("resize", function(){
+  if (chart) chart.applyOptions({height:$("chart").clientHeight});
 });
-onPos(); boot();
+
+/* 브라우저 언어 자동 식별. 저장된 선택이 있으면 그게 이긴다. */
+(async function(){
+  var saved = document.cookie.match(/finchal_lang=(\w+)/);
+  var nav = (navigator.language || "ko").slice(0, 2).toLowerCase();
+  await setLang(saved ? saved[1] : (nav === "ko" ? "ko" : "en"));
+})();
 </script>
 </body>
 </html>