@mulsok/traders-client 0.1.0 → 0.2.1

package/dist/server/server-sync.js

@@ -16,7 +16,8 @@
 import { loadConfig, saveConfig, SERVER_BASE_URL } from "./config.js";
 import { getConditionWatcher } from "./watchers/condition-watcher.js";
 import { readEvents, computeStats } from "./journal/trade-journal.js";
-import { readDiary } from "./diary/writer.js";
+import { computeDailyPnl } from "./journal/pnl-stats.js";
+import { readDiary, listDiariesForPersona } from "./diary/writer.js";
 import { getHoldings, getDeposit } from "./broker/kiwoom/index.js";
 import { loadState } from "./personas/persona-state.js";
 import { getCandles } from "./db/sqlite.js";
@@ -26,10 +27,22 @@ export function getLastSync() {
     return lastSync;
 }
 /* ─────────── 핵심: server ping 호출 ─────────── */
-export async function fetchServerSubscriptions() {
+/**
+ * server `/api/client/ping` 호출 + cfg.auth.userId 갱신 + subscriptions 동기화.
+ *
+ * @param opts.allowBootstrap (default true) · 첫 ping (user_id null) 에서 응답으로
+ *   user_id 받으면 즉시 한 번 더 self-recurse 해서 readiness payload 동봉한 두 번째
+ *   ping 자동 trigger. 이를 끄면 single-shot (recurse 시 internal 로 false).
+ *
+ *   onboarding UX bug 차단: 토큰 등록 직후 readiness 가 1시간 polling 까지 비어있어서
+ *   web dashboard 의 Step 4 진행 안 되던 문제 해결 (2026-05-10 발견).
+ */
+export async function fetchServerSubscriptions(opts = {}) {
+    const allowBootstrap = opts.allowBootstrap ?? true;
     const cfg = loadConfig();
     const token = cfg.auth?.deviceToken;
     const syncedAt = new Date().toISOString();
+    const wasFirstAuth = !cfg.auth?.userId;
     if (!token) {
         const result = {
             ok: false,
@@ -40,142 +53,253 @@ export async function fetchServerSubscriptions() {
         lastSync = result;
         return result;
     }
-    // 클라이언트 readiness payload (server 가 dashboard 에 표시)
-    // ADR-008 익명 원칙: 종목 코드·가격·잔고·자격증명 송신 금지.
-    // 메타·집계·자연어 (intent/reasoning 발췌) 만 OK · 종목 코드는 마스킹 (4자리 → 'XX**').
-    let readinessHeader;
-    try {
-        const cw = getConditionWatcher();
-        const stats = cw.stats();
-        const allWatchers = cw.list({ activeOnly: true });
-        const activeIntents = allWatchers.slice(0, 8).map((w) => ({
-            persona: w.personaSlug,
-            intent: maskSymbolsInText(w.spec.intent),
-            type: w.spec.condition.type,
-            triggerCount: w.triggerCount,
-        }));
-        // 최근 7일 의사결정 통계 (페르소나별 buy/sell/skip)
-        const stats7d = computeRecentStats(7);
-        // 가장 최근 의사결정 1건 (reasoning 발췌 · 종목 마스킹)
-        const lastDecision = getLatestDecision();
-        // 페르소나별 오늘 일기 (있으면 마스킹된 본문)
-        const today = todayKST();
-        const diaries = {};
-        for (const slug of cfg.subscriptions ?? []) {
-            const d = readDiary(today, slug);
-            if (d?.body)
-                diaries[slug] = maskSymbolsInText(d.body);
-        }
-        // 최근 의사결정 5건 (배열)
-        const recentDecisions = getRecentDecisions(5);
-        // 성과 (PnL · 자본) — kiwoom + journal 합산
-        const performance = await computePerformance();
-        // 보유 종목 — kiwoom holdings (종목 마스킹)
-        const holdings = await fetchHoldingsAnonymized();
-        // 페르소나별 인스턴스 상태 (state.json) — 사용자 dashboard 전용
-        // 종목 코드/이름 그대로 송신. 본인의 device_token 인증 readiness 라 본인만 봄.
-        // 합산 텔레메트리 (다른 사용자 노출 가능 영역) 는 ADR-008 마스킹 그대로 유지.
-        // watchlist 의 각 종목에 daily_candles 의 최근 30일 종가 첨부 → dashboard sparkline.
-        const instances = {};
-        for (const slug of cfg.subscriptions ?? []) {
-            try {
-                const state = loadState(slug);
-                const enrichedWatchlist = (state.watchlist ?? []).map((w) => {
-                    let recentCandles;
-                    let recentCloses;
-                    try {
-                        const rows = getCandles(w.code, 30); // DESC · 최대 30일
-                        if (rows.length > 0) {
-                            const ordered = [...rows].reverse(); // 시간순
-                            recentCandles = ordered.map((r) => ({
-                                date: r.date,
-                                open: r.open_krw,
-                                high: r.high_krw,
-                                low: r.low_krw,
-                                close: r.close_krw,
-                                volume: r.volume,
-                            }));
-                            recentCloses = ordered.map((r) => r.close_krw); // 하위 호환 (legacy clients)
-                        }
-                    }
-                    catch {
-                        // candles 미적재 종목 — 차트 없이 진행
-                    }
-                    return { ...w, recentCandles, recentCloses };
-                });
-                instances[slug] = {
-                    lastRunAt: state.lastRunAt,
-                    nextRunAt: state.nextRunAt,
-                    watchlist: enrichedWatchlist,
-                    positions: state.positions,
-                    stats: state.stats,
-                };
+    // 첫 ping (cfg.auth.userId 미설정) 이면 readiness payload 보내지 않음.
+    //   → server 가 token 으로 user_id 식별 후 응답 → 우리가 cfg 에 user_id 저장
+    //   → 이후 ping 부터 user-scoped 데이터 (LOCAL state.json 등) 송신.
+    // 이렇게 해야 token 교체 직후 「이전 user 의 LOCAL data 가 새 user 의
+    // readiness 로 잘못 attribution」 되는 현상을 원천 차단.
+    const knownUserId = cfg.auth?.userId ?? null;
+    let readinessPayload = null;
+    if (knownUserId)
+        try {
+            const cw = getConditionWatcher();
+            const stats = cw.stats();
+            const allWatchers = cw.list({ activeOnly: true });
+            const activeIntents = allWatchers.slice(0, 8).map((w) => ({
+                persona: w.personaSlug,
+                intent: maskSymbolsInText(w.spec.intent),
+                type: w.spec.condition.type,
+                triggerCount: w.triggerCount,
+            }));
+            // 최근 7일 의사결정 통계 (페르소나별 buy/sell/skip)
+            const stats7d = computeRecentStats(7);
+            // 가장 최근 의사결정 1건 (reasoning 발췌 · 종목 마스킹)
+            const lastDecision = getLatestDecision();
+            // 페르소나별 오늘 일기 (있으면 마스킹된 본문)
+            const today = todayKST();
+            const diaries = {};
+            // 페르소나별 최근 7일 일기 archive — web /dashboard/diary 의 archive list 용
+            const recentDiaries = {};
+            for (const slug of cfg.subscriptions ?? []) {
+                const d = readDiary(today, slug);
+                if (d?.body)
+                    diaries[slug] = maskSymbolsInText(d.body);
+                // 최근 7일 archive (오늘 포함)
+                const list = listDiariesForPersona(slug, 7);
+                if (list.length > 0) {
+                    recentDiaries[slug] = list.map((entry) => ({
+                        date: entry.date,
+                        body: maskSymbolsInText(entry.body),
+                        bodyLength: entry.body.length,
+                    }));
+                }
             }
-            catch (e) {
-                console.warn(`[server-sync] persona state 읽기 실패: ${slug}`, e);
+            // 최근 의사결정 5건 (배열)
+            const recentDecisions = getRecentDecisions(5);
+            // 성과 (PnL · 자본) — kiwoom + journal 합산
+            const performance = await computePerformance();
+            // 보유 종목 — kiwoom holdings (종목 마스킹)
+            const holdings = await fetchHoldingsAnonymized();
+            // 페르소나별 인스턴스 상태 (state.json) — 사용자 dashboard 전용
+            // 종목 코드/이름 그대로 송신. 본인의 device_token 인증 readiness 라 본인만 봄.
+            // 합산 텔레메트리 (다른 사용자 노출 가능 영역) 는 ADR-008 마스킹 그대로 유지.
+            // watchlist 의 각 종목에 daily_candles 의 최근 30일 종가 첨부 → dashboard sparkline.
+            const instances = {};
+            for (const slug of cfg.subscriptions ?? []) {
+                try {
+                    const state = loadState(slug);
+                    const enrichedWatchlist = (state.watchlist ?? []).map((w) => {
+                        let recentCandles;
+                        let recentCloses;
+                        try {
+                            const rows = getCandles(w.code, 30); // DESC · 최대 30일
+                            if (rows.length > 0) {
+                                const ordered = [...rows].reverse(); // 시간순
+                                recentCandles = ordered.map((r) => ({
+                                    date: r.date,
+                                    open: r.open_krw,
+                                    high: r.high_krw,
+                                    low: r.low_krw,
+                                    close: r.close_krw,
+                                    volume: r.volume,
+                                }));
+                                recentCloses = ordered.map((r) => r.close_krw); // 하위 호환 (legacy clients)
+                            }
+                        }
+                        catch {
+                            // candles 미적재 종목 — 차트 없이 진행
+                        }
+                        return { ...w, recentCandles, recentCloses };
+                    });
+                    // state.json positions[] 의 raw 필드명 (avgPriceKrw 등) 을 web 의
+                    // InstanceState.positions[] type 에 맞춰 매핑.
+                    // 매핑 안 하면 web /dashboard/[slug] 에서 p.avgCost.toLocaleString() crash.
+                    const mappedPositions = (state.positions ?? []).map((p) => ({
+                        code: p.code,
+                        name: p.name,
+                        quantity: p.quantity,
+                        avgCost: p.avgPriceKrw
+                            ?? p.avgBuyPriceKrw
+                            ?? 0,
+                        boughtAt: p.boughtAt,
+                        // currentPrice / unrealizedPct / unrealizedKrw 는 broker holdings 에서 매칭 가능
+                        // 시 채움 (현재 미구현 — web page 가 null 시 "—" 표시).
+                    }));
+                    instances[slug] = {
+                        lastRunAt: state.lastRunAt,
+                        nextRunAt: state.nextRunAt,
+                        watchlist: enrichedWatchlist,
+                        positions: mappedPositions,
+                        stats: state.stats,
+                    };
+                }
+                catch (e) {
+                    console.warn(`[server-sync] persona state 읽기 실패: ${slug}`, e);
+                }
             }
+            // 디버그 — readiness ping payload 의 핵심 메트릭 stderr 로 출력 (web 측 0 표시
+            // 회귀 추적용 · 2026-05-09)
+            console.log(`[server-sync] readiness build · subs=${cfg.subscriptions?.length ?? 0} · ` +
+                `watchers active=${stats.active} · intents=${activeIntents.length} · ` +
+                `instances=${Object.keys(instances).length}`);
+            const readiness = {
+                // 기본
+                subscriptions_count: cfg.subscriptions?.length ?? 0,
+                active_watchers: stats.active,
+                kiwoom_connected: cfg.broker?.kind === "kiwoom" && !!cfg.broker?.appKey && !!cfg.broker?.appSecret,
+                llm_provider: cfg.llm?.provider ?? "none",
+                // 활동 메타
+                decisions_7d: stats7d.total,
+                decisions_by_action: stats7d.byAction,
+                decisions_by_persona: stats7d.byPersona,
+                last_decision_at: lastDecision?.timestamp ?? null,
+                last_decision: lastDecision
+                    ? {
+                        persona: lastDecision.persona,
+                        action: lastDecision.action,
+                        reasoning_excerpt: lastDecision.reasoning,
+                    }
+                    : null,
+                // 최근 5건 의사결정 (timeline 용)
+                recent_decisions: recentDecisions,
+                // 성과 (사용자 본인만 봄 · 자본 금액 OK · 종목·가격 송신 X)
+                performance,
+                // 보유 종목 (종목명 마스킹 · bp 손익률만)
+                holdings,
+                // watcher 자연어 의도
+                watcher_intents: activeIntents,
+                // 오늘 일기 (페르소나별)
+                today_diaries: diaries,
+                // 최근 7일 일기 archive (페르소나별 · web /dashboard/diary archive list 용)
+                recent_diaries: recentDiaries,
+                // 페르소나별 인스턴스 상태 (사용자 dashboard /dashboard/[slug] 표시용)
+                instances,
+            };
+            // POST body 로 송신 — Vercel header 크기 한계 (16KB) 우회.
+            readinessPayload = readiness;
+        }
+        catch (e) {
+            console.warn("[server-sync] readiness 계산 실패:", e);
         }
-        const readiness = {
-            // 기본
-            subscriptions_count: cfg.subscriptions?.length ?? 0,
-            active_watchers: stats.active,
-            kiwoom_connected: cfg.broker?.kind === "kiwoom" && !!cfg.broker?.appKey && !!cfg.broker?.appSecret,
-            llm_provider: cfg.llm?.provider ?? "none",
-            // 활동 메타
-            decisions_7d: stats7d.total,
-            decisions_by_action: stats7d.byAction,
-            decisions_by_persona: stats7d.byPersona,
-            last_decision_at: lastDecision?.timestamp ?? null,
-            last_decision: lastDecision
-                ? {
-                    persona: lastDecision.persona,
-                    action: lastDecision.action,
-                    reasoning_excerpt: lastDecision.reasoning,
-                }
-                : null,
-            // 최근 5건 의사결정 (timeline 용)
-            recent_decisions: recentDecisions,
-            // 성과 (사용자 본인만 봄 · 자본 금액 OK · 종목·가격 송신 X)
-            performance,
-            // 보유 종목 (종목명 마스킹 · bp 손익률만)
-            holdings,
-            // watcher 자연어 의도
-            watcher_intents: activeIntents,
-            // 오늘 일기 (페르소나별)
-            today_diaries: diaries,
-            // 페르소나별 인스턴스 상태 (사용자 dashboard /dashboard/[slug] 표시용)
-            instances,
-        };
-        // HTTP 헤더는 ByteString (latin-1) — 한국어 그대로 못 들어감.
-        // JSON 직렬화 후 \uXXXX 로 escape (서버 JSON.parse 가 자동 복원).
-        readinessHeader = JSON.stringify(readiness).replace(/[\u0080-\uFFFF]/g, (c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0"));
-    }
-    catch (e) {
-        console.warn("[server-sync] readiness 계산 실패:", e);
-    }
     try {
         const url = `${SERVER_BASE_URL.replace(/\/$/, "")}/api/client/ping`;
+        // POST + JSON body — readinessPayload null 이어도 동봉 (서버는 무시).
         const res = await fetch(url, {
-            method: "GET",
+            method: "POST",
             headers: {
                 Authorization: `Bearer ${token}`,
                 accept: "application/json",
-                ...(readinessHeader ? { "X-Readiness": readinessHeader } : {}),
+                "content-type": "application/json",
             },
-            signal: AbortSignal.timeout(7_000),
+            body: JSON.stringify({ readiness: readinessPayload }),
+            signal: AbortSignal.timeout(10_000),
         });
         if (!res.ok) {
             const text = await res.text().catch(() => "");
             throw new Error(`HTTP ${res.status} · ${text.slice(0, 80)}`);
         }
         const ping = (await res.json());
-        // 인증 성공 시에만 subscriptions 동기화 (인증 실패 = 캐시 유지)
+        // 인증 결과 분기 (v2 schema):
+        //   - 성공: server SSoT 로 user_id 확정. user_id 가 기존과 다르면 active
+        //     user slot 만 전환 (이전 user 의 LOCAL fs / settings 는 자기 슬롯에
+        //     보존됨 — v2 핵심 격리). 메모리 singleton 만 reset.
+        //   - 실패 (HTTP 200 + authenticated:false): server 가 명시 거부 →
+        //     로그아웃 의미. cfg.auth 비움 (users[*] 슬롯은 유지).
+        //     (network error 는 catch 블록이 잡음 → 그대로)
         if (ping.authenticated) {
+            const newUserId = ping.user_id ?? null;
+            const newUserEmail = ping.user_email ?? undefined;
+            const prevUserId = cfg.auth?.userId ?? null;
+            const userChanged = !!newUserId && !!prevUserId && newUserId !== prevUserId;
+            if (userChanged) {
+                console.warn(`[server-sync] user 변경: ${prevUserId} → ${newUserId} · 메모리 singleton reset`);
+                // user 별 in-memory 상태들을 모두 reset. fs 의 user-scoped 데이터는
+                // v2 schema 가 자체 격리하므로 wipe 불필요.
+                try {
+                    getConditionWatcher().clearAll();
+                }
+                catch { /* ignore */ }
+                try {
+                    const { getOrderTracker, getPriceFeed, getKiwoomWs } = await import("./broker/kiwoom/index.js");
+                    getOrderTracker().reset?.();
+                    getPriceFeed().unsubscribeAll?.();
+                    // broker 자격증명도 user 별로 다르므로 WS session 끊기 (새 user 의
+                    // broker 자격증명으로 lazy reconnect 됨).
+                    await getKiwoomWs().disconnect?.();
+                }
+                catch { /* ignore · 일부 헬퍼 미구현 OK */ }
+                try {
+                    const { getTelemetry } = await import("./journal/telemetry.js");
+                    getTelemetry().clearQueue?.();
+                }
+                catch { /* ignore */ }
+            }
+            // active user 의 subscriptions 갱신 — 항상 2-step.
+            //   Step 1: auth 만 갱신 (saveConfig 가 settings 무시 → leak 차단)
+            //   Step 2: 새 user 컨텍스트로 loadConfig 재실행 → 그 슬롯에 subs 기록
+            // 첫 로그인 / 동일 user / user 전환 모든 케이스 일관 처리.
             const slugs = (ping.subscriptions ?? [])
                 .filter((s) => s.status === "live")
                 .map((s) => s.persona_slug);
-            const updated = { ...cfg, subscriptions: slugs.sort() };
-            saveConfig(updated);
+            // Step 1: auth 갱신
+            saveConfig({
+                ...cfg,
+                auth: {
+                    ...cfg.auth,
+                    userId: newUserId ?? cfg.auth?.userId,
+                    userEmail: newUserEmail ?? cfg.auth?.userEmail,
+                },
+            });
+            // Step 2: 활성 user 슬롯의 subscriptions 갱신
+            const fresh = loadConfig();
+            saveConfig({
+                ...fresh,
+                subscriptions: slugs.sort(),
+            });
+            // 첫 인증 (prevUserId null → newUserId 알게 됨) 또는 user 변경 후:
+            // 새 user 의 watchers 를 DB 에서 복원
+            if ((!prevUserId && newUserId) || userChanged) {
+                try {
+                    await getConditionWatcher().restoreFromDb();
+                }
+                catch (e) {
+                    console.warn("[server-sync] post-auth watcher restore 실패:", e);
+                }
+            }
+        }
+        else {
+            // server 가 token 거부 → 로그아웃 처리
+            // cfg.auth 비움 + 메모리 watchers 정리. users[*] 슬롯은 보존 (재로그인 대비)
+            if (cfg.auth?.userId || cfg.auth?.deviceToken) {
+                saveConfig({
+                    ...cfg,
+                    auth: { deviceToken: undefined, userId: undefined, userEmail: undefined },
+                });
+                try {
+                    getConditionWatcher().clearAll();
+                }
+                catch { /* ignore */ }
+            }
         }
         const result = {
             ok: true,
@@ -184,6 +308,15 @@ export async function fetchServerSubscriptions() {
             ping,
         };
         lastSync = result;
+        // ── Self-bootstrap (onboarding UX fix · 2026-05-10) ──
+        // 첫 ping 은 cfg.auth.userId=null 이라 readiness payload 안 보냄.
+        // server 응답으로 user_id 받았으면 즉시 한 번 더 self-recurse 해서 readiness
+        // 동봉한 두 번째 ping. 이전엔 1시간 cron 까지 wait → web dashboard Step 4 진입 X.
+        // recursion depth 1 cap (allowBootstrap=false 로 재귀).
+        if (allowBootstrap && wasFirstAuth && ping.authenticated && ping.user_id) {
+            console.log(`[server-sync] bootstrap — 첫 인증 완료 (user_id=${ping.user_id}) · readiness 동봉 두 번째 ping 즉시 trigger`);
+            return await fetchServerSubscriptions({ allowBootstrap: false });
+        }
         return result;
     }
     catch (e) {
@@ -197,16 +330,124 @@ export async function fetchServerSubscriptions() {
         return result;
     }
 }
+/* ─────────── Phase 5e-3 · 시세 incremental pull ─────────── */
+import { upsertCandlesBulk, upsertUniverseBulk, } from "./db/sqlite.js";
+/**
+ * vercel `/api/market/candles` 에서 자기 SQLite max(date) 이후 candle 만 pull.
+ *
+ * 첫 install 케이스 (max=00000000) 면 page loop 로 전체 download.
+ * 매일 호출 시 (max=어제) 면 1 page 로 ~3K row 빠르게 끝남.
+ *
+ * 멱등 — upsertCandlesBulk 가 PK (code,date) 기준 ON CONFLICT.
+ * 도중 실패 시 다음 호출이 같은 since 부터 재시작 (중복 다운로드 안전).
+ *
+ * onProgress 콜백 — 매 page 후 호출. prepare CLI / WebUI 의 progress bar source.
+ */
+export async function pullCandlesFromServer(opts = {}) {
+    const cfg = loadConfig();
+    const token = cfg.auth?.deviceToken;
+    if (!token)
+        return { ok: false, error: "device_token 미설정" };
+    const { getDb } = await import("./db/sqlite.js");
+    const db = getDb();
+    const maxRow = db.prepare("SELECT MAX(date) AS d FROM daily_candles").get();
+    let since = maxRow.d ?? "00000000";
+    const PAGE_LIMIT = 200_000;
+    let totalAdded = 0;
+    let pages = 0;
+    const MAX_PAGES = 100; // 안전 cap (10.87M row / 200K = 55 page · 충분 마진)
+    for (let i = 0; i < MAX_PAGES; i++) {
+        const url = `${SERVER_BASE_URL}/api/market/candles?since=${since}&limit=${PAGE_LIMIT}`;
+        let res;
+        try {
+            res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+        }
+        catch (e) {
+            return { ok: false, error: `네트워크 실패: ${String(e)}`, candlesAdded: totalAdded, pages };
+        }
+        if (!res.ok) {
+            return { ok: false, error: `HTTP ${res.status}`, candlesAdded: totalAdded, pages };
+        }
+        const body = (await res.json());
+        if (!body.ok) {
+            return { ok: false, error: "server 응답 ok=false", candlesAdded: totalAdded, pages };
+        }
+        if (body.candles.length > 0) {
+            upsertCandlesBulk(body.candles);
+            totalAdded += body.candles.length;
+        }
+        pages++;
+        opts.onProgress?.(pages, totalAdded, body.next_since);
+        if (!body.has_more)
+            break;
+        if (body.next_since === since)
+            break; // 안전: cursor 가 안 움직이면 무한 루프 방지
+        since = body.next_since;
+    }
+    return { ok: true, candlesAdded: totalAdded, pages };
+}
+/**
+ * vercel `/api/market/universe` 에서 전종목 마스터 full pull.
+ * universe 는 ~4,300 row 라 incremental 불필요 — 매번 full + upsert.
+ */
+export async function pullUniverseFromServer() {
+    const cfg = loadConfig();
+    const token = cfg.auth?.deviceToken;
+    if (!token)
+        return { ok: false, error: "device_token 미설정" };
+    let res;
+    try {
+        res = await fetch(`${SERVER_BASE_URL}/api/market/universe`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+    }
+    catch (e) {
+        return { ok: false, error: `네트워크 실패: ${String(e)}` };
+    }
+    if (!res.ok)
+        return { ok: false, error: `HTTP ${res.status}` };
+    const body = (await res.json());
+    if (!body.ok)
+        return { ok: false, error: "server 응답 ok=false" };
+    if (body.universe.length > 0) {
+        upsertUniverseBulk(body.universe);
+    }
+    return { ok: true, universeAdded: body.universe.length };
+}
 /* ─────────── 주기 동기화 (서버 시작 시 + 1시간마다) ─────────── */
 let intervalTimer = null;
 export function startPeriodicSync(intervalMs = 3600_000) {
     if (intervalTimer)
         return;
     void fetchServerSubscriptions(); // 즉시 1회
+    // 시세 pull 도 startup + 매 interval 마다. 첫 install 첫 호출이 무거우니 별도 fire.
+    void runMarketPull();
     intervalTimer = setInterval(() => {
         void fetchServerSubscriptions();
+        void runMarketPull();
     }, intervalMs);
-    console.log(`[server-sync] started · ${intervalMs / 1000}s interval`);
+    console.log(`[server-sync] started · ${intervalMs / 1000}s interval (subs + market pull)`);
+}
+async function runMarketPull() {
+    try {
+        const u = await pullUniverseFromServer();
+        if (!u.ok) {
+            console.warn(`[market-pull] universe 실패: ${u.error}`);
+        }
+        else if ((u.universeAdded ?? 0) > 0) {
+            console.log(`[market-pull] universe ${u.universeAdded} row upsert`);
+        }
+        const c = await pullCandlesFromServer();
+        if (!c.ok) {
+            console.warn(`[market-pull] candles 실패: ${c.error} (added=${c.candlesAdded ?? 0})`);
+        }
+        else if ((c.candlesAdded ?? 0) > 0) {
+            console.log(`[market-pull] candles ${c.candlesAdded} row · ${c.pages} page`);
+        }
+    }
+    catch (e) {
+        console.error("[market-pull] 예외:", e);
+    }
 }
 export function stopPeriodicSync() {
     if (intervalTimer)
@@ -356,10 +597,14 @@ async function computePerformance() {
     try {
         const from = new Date(Date.now() - 30 * 86400_000).toISOString();
         const stats = computeStats({ from });
-        result.realized_pnl_krw_30d = Math.round(stats.realizedPnlKrw);
+        // computeStats.realizedPnlKrw 는 단순 sell-buy 차 (FIFO 미구현 · 매수만
+        // 있으면 음수로 잘못 표시). 정확한 FIFO 기반 실현 손익은 pnl-stats 의
+        // computeDailyPnl 사용.
         result.win_rate_pct = Math.round(stats.winRate * 10) / 10;
         result.total_decisions_30d = stats.totalDecisions;
         result.total_orders_30d = stats.totalOrders;
+        const pnl = computeDailyPnl({ from });
+        result.realized_pnl_krw_30d = Math.round(pnl.totalRealizedPnlKrw);
     }
     catch { /* ignore */ }
     // kiwoom 예수금 + holdings (broker 설정 시만)
@@ -367,8 +612,13 @@ async function computePerformance() {
     if (cfg.broker?.kind === "kiwoom" && cfg.broker?.appKey && cfg.broker?.appSecret) {
         try {
             const dep = await getDeposit();
-            if (dep.ok)
-                result.cash_krw = dep.data.totalDepositKrw;
+            if (dep.ok) {
+                // 키움 entr (= totalDepositKrw) 는 D+2 결제 전 cash. 매수 결제가 아직
+                // cash 에서 빠지지 않은 상태라 평가액과 더하면 매수 원금이 양쪽에
+                // 중복 계산됨 (회귀: 100만 입금 → 130만 표시). availableKrw (가용 cash,
+                // = D+2 결제 후 잔액 의미) 를 cash 의미로 사용.
+                result.cash_krw = dep.data.availableKrw || dep.data.totalDepositKrw;
+            }
         }
         catch { /* ignore */ }
         try {
@@ -405,6 +655,17 @@ async function fetchHoldingsAnonymized() {
         return [];
     }
 }
+/**
+ * `<state_update>...</state_update>` 블록 제거 (ADR-014 agent guard).
+ * agent prompt 가 응답 끝에 zod 직렬화용 블록을 강제하는데, reasoning_excerpt 송신 시
+ * 그대로 포함되면 web dashboard 의 ReactMarkdown 이 unknown HTML 태그로 처리해
+ * 텍스트가 깨져 보임 (사용자 보고 2026-05-09).
+ */
+function stripStateUpdate(text) {
+    return text.replace(/<state_update>[\s\S]*?<\/state_update>\s*$/i, "")
+        .replace(/<state_update>[\s\S]*?<\/state_update>/gi, "")
+        .trimEnd();
+}
 function extractReasoningText(raw) {
     if (!raw)
         return "";
@@ -414,14 +675,14 @@ function extractReasoningText(raw) {
         const t = m ? m[1] : raw;
         const obj = JSON.parse(t);
         if (typeof obj.reasoning === "string")
-            return obj.reasoning;
+            return stripStateUpdate(obj.reasoning);
     }
     catch { /* not JSON · markdown 또는 자유 텍스트 */ }
     // 2) "reasoning": "..." 단일 키 정규식 — 줄바꿈 보존
     const m2 = raw.match(/"reasoning"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
     if (m2)
-        return m2[1].replace(/\\n/g, "\n").replace(/\\"/g, '"');
-    // 3) markdown · 자유 텍스트 응답 — 풀 본문 그대로 반환 (호출부에서 cap 처리)
-    return raw;
+        return stripStateUpdate(m2[1].replace(/\\n/g, "\n").replace(/\\"/g, '"'));
+    // 3) markdown · 자유 텍스트 응답 — <state_update> 블록 제거 후 본문만
+    return stripStateUpdate(raw);
 }
 //# sourceMappingURL=server-sync.js.map