@mulsok/traders-client 0.1.0

package/dist/server/routes.js

@@ -0,0 +1,1216 @@
+import fs from "node:fs";
+import { z } from "zod";
+import { loadConfig, saveConfig, maskedConfig, mergeConfigPatch, DEFAULT_CONFIG, CONFIG_PATHS, SERVER_BASE_URL, } from "./config.js";
+import { createLlmProvider } from "./llm/index.js";
+import { fetchCommonBundle, fetchPersonaBundle, assembleFullPrompt } from "./bundle.js";
+import { runReadinessCheck } from "./readiness.js";
+import { buildLayer3Header, loadActivePatches } from "./llm/context-builder.js";
+import { logDecision } from "./journal/trade-journal.js";
+import { getConditionWatcher } from "./watchers/condition-watcher.js";
+import { getPriceFeed, getOrderTracker } from "./broker/kiwoom/index.js";
+import { computeStats, listJournalFiles, readEvents } from "./journal/trade-journal.js";
+import { getTelemetry } from "./journal/telemetry.js";
+import { getStockUniverse, getStandardUniverse, getMarketIndex, getAllSectorIndices, getSectorCodes, getForeignActivity, getInstitutionActivity, getContinuousInvestorActivity, getVolumeSurgeRanking, getYesterdayVolumeRanking, getDailyTradeDetail, getDailyStockPrice, listThemeGroups, getThemeMembers, getAccountAssessment, getExecutionBalance, getAccountDailyStatus, getAccountProfitRate, getTradeDiary, listConditions, requestCondition, getKiwoomWs, } from "./broker/kiwoom/index.js";
+import { countUniverse, getSyncMeta, listUniverse, vacuumWatchersOlderThan, watchersTableStats } from "./db/sqlite.js";
+import { runUniverseSync } from "./jobs/universe-sync.js";
+import { runScreener } from "./screener/engine.js";
+import { loadPersona, reloadPersona, PERSONA_OVERRIDE_DIR } from "./personas/loader.js";
+import { listAvailablePersonas, runPersonaScreening } from "./personas/runner.js";
+// SPEC-27 (ADR-011): executePersonaDecision 폐기 → executePersonaCycle (lazy import)
+import { fetchServerSubscriptions, getLastSync } from "./server-sync.js";
+import { writeDiary, readDiary, listDiariesForPersona } from "./diary/writer.js";
+import { extractWakePlan, registerWakePlan } from "./personas/wake-plan.js";
+export async function registerRoutes(app) {
+    // ── 헬스체크 ────────────────────────────────────────────────
+    app.get("/api/health", async () => {
+        const cfg = loadConfig();
+        return {
+            ok: true,
+            service: "@mulsok/client",
+            version: "0.0.0",
+            node: process.version,
+            config: {
+                present: fs.existsSync(CONFIG_PATHS.file),
+                path: CONFIG_PATHS.file,
+                provider: cfg.llm.provider,
+                server_base: SERVER_BASE_URL,
+            },
+        };
+    });
+    // ── Config ──────────────────────────────────────────────────
+    app.get("/api/config", async () => {
+        const cfg = loadConfig();
+        return { config: maskedConfig(cfg), default: DEFAULT_CONFIG };
+    });
+    /**
+     * POST /api/config · partial merge 의미.
+     *
+     * 규칙 (자세한 정의는 `mergeConfigPatch` 참조):
+     *   - patch 에 없는 최상위 섹션은 **기존 유지** (default 리셋 X)
+     *   - 비밀값: 빈 문자열·미포함·마스킹 sentinel → 기존 유지
+     *   - 공개값 (provider · model · broker.kind · isDemo · halted): 명시 시 교체
+     */
+    app.post("/api/config", async (req, reply) => {
+        const body = (req.body ?? {});
+        const existing = loadConfig();
+        try {
+            const merged = mergeConfigPatch(existing, body);
+            const saved = saveConfig(merged);
+            return { ok: true, config: maskedConfig(saved) };
+        }
+        catch (e) {
+            const issues = e.issues;
+            reply.code(400);
+            return { ok: false, error: "스키마 오류", issues };
+        }
+    });
+    // ── Readiness Check · 거래 준비 상태 종합 ──────────────────
+    app.get("/api/readiness", async () => {
+        return runReadinessCheck();
+    });
+    // ── Setup Wizard · 초기 설정 5단계 검증 ──────────────────
+    // 사용자가 webui 에서 거래 준비 완료 까지 단계별 진단.
+    // 각 step: { ok, label, detail, action? }
+    app.get("/api/setup/wizard", async () => {
+        const fs = await import("node:fs");
+        const path = await import("node:path");
+        const { spawn } = await import("node:child_process");
+        // monorepo root 검출: cwd 부터 위로 .git 디렉토리 찾기
+        const findGitRoot = (start) => {
+            let cur = start;
+            const fsLocal = fs;
+            while (cur !== "/" && cur !== "") {
+                if (fsLocal.existsSync(path.join(cur, ".git")))
+                    return cur;
+                cur = path.dirname(cur);
+            }
+            return start;
+        };
+        const projectRoot = process.env.MULSOK_PROJECT_ROOT ?? findGitRoot(process.cwd());
+        const steps = [];
+        // Step 1: Claude CLI 설치
+        const claudeOk = await new Promise((resolve) => {
+            const child = spawn("claude", ["--version"]);
+            let out = "";
+            child.stdout.on("data", (d) => { out += d.toString(); });
+            child.on("close", (code) => resolve({ ok: code === 0, version: out.trim() }));
+            child.on("error", () => resolve({ ok: false }));
+            setTimeout(() => resolve({ ok: false }), 5000);
+        });
+        steps.push({
+            id: "claude_cli",
+            ok: claudeOk.ok,
+            label: "Claude 도구",
+            detail: claudeOk.ok ? `준비됨 · ${claudeOk.version ?? ""}` : "Claude 명령줄 도구를 찾지 못했어요",
+            action: claudeOk.ok ? undefined : "claude.com/claude-code 에서 설치",
+        });
+        // Step 2: trader-tools Skill 존재
+        const skillPath = path.join(projectRoot, ".claude/skills/trader-tools/SKILL.md");
+        const skillOk = fs.existsSync(skillPath);
+        steps.push({
+            id: "skill_present",
+            ok: skillOk,
+            label: "내장 도구 모듈",
+            detail: skillOk ? "준비됨" : "도구 모듈이 누락됐어요",
+            action: skillOk ? undefined : "앱을 다시 설치하세요",
+        });
+        // Step 3: Skill helper scripts 실행 권한
+        const scriptsDir = path.join(projectRoot, ".claude/skills/trader-tools/scripts");
+        let scriptsOk = false;
+        let scriptsCount = 0;
+        if (fs.existsSync(scriptsDir)) {
+            const entries = fs.readdirSync(scriptsDir).filter((f) => f.endsWith(".sh"));
+            scriptsCount = entries.length;
+            scriptsOk = entries.every((f) => {
+                try {
+                    const stat = fs.statSync(path.join(scriptsDir, f));
+                    return (stat.mode & 0o111) !== 0;
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        steps.push({
+            id: "skill_scripts",
+            ok: scriptsOk && scriptsCount >= 5,
+            label: "도구 실행 권한",
+            detail: scriptsOk ? "준비됨" : "권한이 부족합니다",
+            action: scriptsOk ? undefined : `chmod +x ${scriptsDir}/*.sh`,
+        });
+        // Step 4: 키움 토큰 (account/status)
+        const cfg = loadConfig();
+        let kiwoomOk = false;
+        let kiwoomDetail = "증권사가 설정되지 않았어요";
+        if (cfg.broker.kind === "kiwoom" && cfg.broker.appKey && cfg.broker.appSecret) {
+            try {
+                const { getDeposit } = await import("./broker/kiwoom/index.js");
+                const r = await getDeposit();
+                kiwoomOk = r.ok;
+                kiwoomDetail = r.ok
+                    ? `연결됨 · 예수금 ${r.data.totalDepositKrw.toLocaleString()}원`
+                    : `연결 실패 — ${r.error.message}`;
+            }
+            catch (e) {
+                kiwoomDetail = `연결 오류 — ${String(e)}`;
+            }
+        }
+        steps.push({
+            id: "kiwoom_auth",
+            ok: kiwoomOk,
+            label: "증권사 계좌 연결",
+            detail: kiwoomDetail,
+            action: kiwoomOk ? undefined : "설정 탭에서 증권사 정보를 입력하세요",
+        });
+        // Step 5: 구독한 트레이더
+        const cfgForSubs = loadConfig();
+        const subs = cfgForSubs.subscriptions ?? [];
+        let subDetail;
+        let subOk = false;
+        if (subs.length === 0) {
+            subDetail = "구독한 트레이더가 없어요";
+            subOk = false;
+        }
+        else {
+            try {
+                const persona = await loadPersona(subs[0]);
+                subOk = !!persona;
+                subDetail = persona
+                    ? `${subs.length}명 구독 중`
+                    : "트레이더 정보를 불러오지 못했어요";
+            }
+            catch {
+                subDetail = "트레이더 정보를 불러오지 못했어요";
+            }
+        }
+        steps.push({
+            id: "persona_subscribed",
+            ok: subOk,
+            label: "구독한 트레이더",
+            detail: subDetail,
+            action: subOk ? undefined : "마켓에서 트레이더를 구독하세요",
+        });
+        const passedCount = steps.filter((s) => s.ok).length;
+        return {
+            ok: passedCount === steps.length,
+            passed: passedCount,
+            total: steps.length,
+            ready: passedCount === steps.length,
+            steps,
+            next: passedCount === steps.length
+                ? "거래 준비 완료 · /api/screen/<persona>/decide 호출 가능"
+                : `${steps.length - passedCount} 단계 남음`,
+        };
+    });
+    // ── Watchers (Phase 3 · LLM wake_plan.watchers 등록 · 모니터링) ──
+    // POST /api/watchers · LLM 응답에서 wake_plan.watchers 받아 등록
+    // GET  /api/watchers · 활성 watcher 목록
+    // DELETE /api/watchers/:id · 단일 해제
+    // composite 는 MVP 에서 schema 제외 · ConditionWatcher.startComposite 도 미구현 (P3 후속)
+    const ConditionConfigSchema = z.discriminatedUnion("type", [
+        z.object({
+            type: z.literal("price"),
+            config: z.object({
+                symbolCode: z.string(),
+                metric: z.enum([
+                    "current_price",
+                    "change_pct",
+                    "from_buy_price_pct",
+                    "from_open_pct",
+                    "volume_ratio_d1",
+                ]),
+                op: z.enum(["gte", "gt", "lte", "lt", "eq"]),
+                value: z.number(),
+                buyPriceKrw: z.number().positive().optional(),
+                checkIntervalMs: z.number().int().positive().optional(),
+            }),
+        }),
+        z.object({
+            type: z.literal("event"),
+            config: z.object({
+                symbolCode: z.string(),
+                metric: z.enum([
+                    "ma_touch",
+                    "ma_break_below",
+                    "ma_break_above",
+                    "bullish_engulfing",
+                    "high_volume_bearish",
+                    "previous_low_break",
+                    "candle_volume_surge",
+                ]),
+                maPeriod: z.union([z.literal(5), z.literal(10), z.literal(20), z.literal(60), z.literal(120)]).optional(),
+                volumeMultiple: z.number().positive().optional(),
+                checkIntervalMs: z.number().int().positive().optional(),
+            }),
+        }),
+        z.object({
+            type: z.literal("time"),
+            config: z.object({
+                at: z.string().optional(),
+                afterMs: z.number().int().positive().optional(),
+            }),
+        }),
+    ]);
+    const ConditionSpecSchema = z.object({
+        intent: z.string().min(1),
+        condition: ConditionConfigSchema,
+        wakeAction: z.string().min(1),
+        maxWaitHours: z.number().positive().max(720),
+        repeat: z.boolean().optional(),
+    });
+    const RegisterWatchersSchema = z.object({
+        personaSlug: z.string().min(1),
+        /** LLM 출력에서는 wake_plan.watchers 배열 그대로 */
+        watchers: z.array(ConditionSpecSchema).max(20),
+    });
+    app.post("/api/watchers", async (req, reply) => {
+        const parsed = RegisterWatchersSchema.safeParse(req.body);
+        if (!parsed.success) {
+            reply.code(400);
+            return { ok: false, error: "스키마 오류", issues: parsed.error.issues };
+        }
+        const cw = getConditionWatcher();
+        const registered = [];
+        const rejected = [];
+        for (const spec of parsed.data.watchers) {
+            try {
+                registered.push(cw.add(parsed.data.personaSlug, spec));
+            }
+            catch (e) {
+                rejected.push({ intent: spec.intent, reason: String(e) });
+            }
+        }
+        if (rejected.length > 0 && registered.length === 0) {
+            reply.code(400);
+            return { ok: false, error: "모든 watcher 등록 거부", rejected };
+        }
+        return {
+            ok: true,
+            count: registered.length,
+            watchers: registered.map((w) => ({
+                id: w.id,
+                intent: w.spec.intent,
+                type: w.spec.condition.type,
+                expiresAt: w.expiresAt,
+            })),
+            ...(rejected.length > 0 ? { rejected } : {}),
+        };
+    });
+    app.get("/api/watchers", async (req) => {
+        const q = req.query;
+        const cw = getConditionWatcher();
+        const list = cw.list({
+            personaSlug: q.personaSlug,
+            activeOnly: q.activeOnly === "true",
+        });
+        // SQLite watchers 테이블 누적 통계 (P1-4 보강 · 모니터링용 · vacuum 시점 판단)
+        let dbStats = null;
+        try {
+            dbStats = watchersTableStats();
+        }
+        catch (e) {
+            // SQLite 일시 장애 등 — 응답에 영향 X
+            console.warn("[/api/watchers] watchersTableStats 실패:", e);
+        }
+        return {
+            stats: cw.stats(),
+            dbStats,
+            priceFeed: getPriceFeed().stats(),
+            watchers: list,
+        };
+    });
+    // ── Screening (범용 · 페르소나 frontmatter 기반) ──────────
+    //
+    // GET /api/screen/:personaId
+    //   → loadPersona → frontmatter.screener → engine 실행
+    //   → 페르소나 추가 시 코드 수정 0 (Supabase body frontmatter 또는 로컬 override)
+    //
+    // 이전 경로 /api/screening/neoul 도 동일 동작으로 유지 (호환).
+    app.get("/api/screen/:personaId", async (req, reply) => {
+        const { personaId } = req.params;
+        const r = await runPersonaScreening(personaId);
+        if (!r) {
+            reply.code(404);
+            return { ok: false, error: `persona '${personaId}' 를 찾을 수 없음 (Supabase 와 로컬 override 모두 미존재)` };
+        }
+        return { ok: true, ...r };
+    });
+    app.get("/api/screening/neoul", async (_req, reply) => {
+        // 레거시 alias · v1.9 에서 삭제 예정
+        reply.header("Deprecation", "true");
+        reply.header("Link", '</api/screen/neoul>; rel="successor-version"');
+        const r = await runPersonaScreening("neoul");
+        if (!r) {
+            reply.code(404);
+            return { ok: false, error: "persona 'neoul' 미존재" };
+        }
+        return { ok: true, ...r };
+    });
+    // ── Personas (발견 · 목록) ──────────────────────────────
+    app.get("/api/personas", async (req) => {
+        const q = req.query;
+        const slugs = (q.slugs ?? "neoul").split(",").map((s) => s.trim()).filter(Boolean);
+        const results = await listAvailablePersonas(slugs);
+        return { ok: true, items: results, overrideDir: PERSONA_OVERRIDE_DIR };
+    });
+    app.post("/api/personas/:personaId/reload", async (req, reply) => {
+        const { personaId } = req.params;
+        const r = await reloadPersona(personaId);
+        if (!r) {
+            reply.code(404);
+            return { ok: false, error: `persona '${personaId}' 리로드 실패` };
+        }
+        return { ok: true, persona: { slug: r.slug, version: r.frontmatter.version, source: r.source } };
+    });
+    // ── Persona agent cycle (SPEC-27 · ADR-011 stateful agent) ────
+    //
+    // POST /api/personas/:slug/cycle
+    //   - claude-cli agent 가 자기 state.json/strategy.md read → 도구 호출 → 결정 → write
+    //   - Layer 3 정적 조립 폐기 (agent 가 동적 read)
+    //   - 이전 stateless `executePersonaDecision` 호출 폐기 (호환은 deprecation alias 유지)
+    app.post("/api/personas/:slug/cycle", async (req, reply) => {
+        const { slug } = req.params;
+        const body = (req.body ?? {});
+        const { executePersonaCycle } = await import("./personas/persona-agent.js");
+        const result = await executePersonaCycle(slug, {
+            kind: body.triggerKind ?? "manual",
+            intent: body.intent,
+            watcherId: body.watcherId,
+        });
+        if (!result.ok)
+            reply.code(result.stage === "persona" ? 404 : result.stage === "safety" ? 403 : 500);
+        return result;
+    });
+    // GET /api/personas/:slug/state — state.json read (UI · watchdog · 디버깅용)
+    app.get("/api/personas/:slug/state", async (req, reply) => {
+        const { slug } = req.params;
+        try {
+            const { loadState } = await import("./personas/persona-state.js");
+            return { ok: true, state: loadState(slug) };
+        }
+        catch (e) {
+            reply.code(500);
+            return { ok: false, error: String(e) };
+        }
+    });
+    // GET /api/personas/:slug/strategy — strategy.md read (UI · 사용자 노출용)
+    app.get("/api/personas/:slug/strategy", async (req, reply) => {
+        const { slug } = req.params;
+        try {
+            const { loadStrategy } = await import("./personas/persona-state.js");
+            return { ok: true, slug, strategy: loadStrategy(slug) };
+        }
+        catch (e) {
+            reply.code(500);
+            return { ok: false, error: String(e) };
+        }
+    });
+    // POST /api/orders — agent 도구: 안전 게이트 통과한 매수/매도
+    app.post("/api/orders", async (req, reply) => {
+        const body = (req.body ?? {});
+        if (!body.personaSlug || !body.symbolCode || !body.side || !body.quantity) {
+            reply.code(400);
+            return { ok: false, error: "personaSlug · symbolCode · side · quantity 필수" };
+        }
+        const { checkOrderSafety } = await import("./safety.js");
+        const safety = await checkOrderSafety({
+            personaSlug: body.personaSlug,
+            symbolCode: body.symbolCode,
+            side: body.side,
+            quantity: body.quantity,
+            priceKrw: body.priceKrw,
+        });
+        if (!safety.ok) {
+            reply.code(403);
+            return { ok: false, deniedCode: safety.code, reason: safety.reason };
+        }
+        try {
+            const { placeOrderWithTracking } = await import("./broker/kiwoom/index.js");
+            const placed = await placeOrderWithTracking({
+                symbolCode: body.symbolCode,
+                side: body.side,
+                quantity: body.quantity,
+                priceKrw: body.priceKrw,
+                type: body.priceKrw ? "limit" : "market",
+            }, { personaSlug: body.personaSlug });
+            if (!placed.ok) {
+                return { ok: false, error: placed.error.message };
+            }
+            return {
+                ok: true,
+                clientOrderId: placed.data.clientOrderId,
+                brokerOrderNo: placed.data.brokerOrderNo,
+                status: placed.data.status,
+            };
+        }
+        catch (e) {
+            reply.code(500);
+            return { ok: false, error: String(e) };
+        }
+    });
+    // ── (Deprecated · ADR-011) stateless decide alias ────────────
+    //   기존 호출자 호환만. 새 코드는 /api/personas/:slug/cycle 사용.
+    app.post("/api/screen/:personaId/decide", async (req, reply) => {
+        const { personaId } = req.params;
+        reply.header("Deprecation", "true");
+        reply.header("Link", `</api/personas/${personaId}/cycle>; rel="successor-version"`);
+        const { executePersonaCycle } = await import("./personas/persona-agent.js");
+        const result = await executePersonaCycle(personaId, { kind: "manual" });
+        if (!result.ok)
+            reply.code(result.stage === "persona" ? 404 : 500);
+        return result;
+    });
+    // ── wake_plan 파싱 + 등록 테스트 (LLM 없이 로직만 검증) ──
+    app.post("/api/test/wake-plan", async (req, reply) => {
+        const body = (req.body ?? {});
+        if (!body.llmResponseText) {
+            reply.code(400);
+            return { ok: false, error: "llmResponseText 필수" };
+        }
+        const persona = body.personaSlug ?? "neoul";
+        const extracted = extractWakePlan(body.llmResponseText);
+        if (!extracted.ok || !extracted.wakePlan) {
+            return { ok: false, stage: "parse", error: extracted.error, rawJson: extracted.rawJson };
+        }
+        if (body.dryRun) {
+            return { ok: true, dryRun: true, wakePlan: extracted.wakePlan };
+        }
+        const reg = registerWakePlan(persona, extracted.wakePlan);
+        return {
+            ok: true,
+            wakePlan: extracted.wakePlan,
+            registered: reg.registered.length,
+            skipped: reg.skipped.length,
+            nextScheduledRegistered: reg.nextScheduledRegistered,
+            watchers: reg.registered.map((w) => ({ id: w.id, intent: w.spec.intent, expiresAt: w.expiresAt })),
+            skipReasons: reg.skipped.map((s) => s.reason),
+        };
+    });
+    app.post("/api/screening/neoul/decide", async (_req, reply) => {
+        // 이중 레거시 alias (SPEC-27 ADR-011 후 폐기)
+        reply.header("Deprecation", "true");
+        reply.header("Link", '</api/personas/neoul/cycle>; rel="successor-version"');
+        const { executePersonaCycle } = await import("./personas/persona-agent.js");
+        const result = await executePersonaCycle("neoul", { kind: "manual" });
+        if (!result.ok)
+            reply.code(result.stage === "persona" ? 404 : 500);
+        return result;
+    });
+    // ── Safety · Emergency Stop (SPEC-26) ──
+    // GET  /api/safety           · 현 상태 (halted · 사유)
+    // POST /api/safety/halt      · 응급 정지 활성 (모든 주문/LLM 호출 차단)
+    // POST /api/safety/resume    · 정지 해제
+    app.get("/api/safety", async () => {
+        const cfg = loadConfig();
+        return { halted: cfg.halted ?? false };
+    });
+    app.post("/api/safety/halt", async (req) => {
+        const body = (req.body ?? {});
+        const cfg = loadConfig();
+        saveConfig({ ...cfg, halted: true });
+        console.warn(`[safety] HALTED · reason: ${body.reason ?? "(no reason)"}`);
+        return { ok: true, halted: true, reason: body.reason ?? null };
+    });
+    app.post("/api/safety/resume", async () => {
+        const cfg = loadConfig();
+        saveConfig({ ...cfg, halted: false });
+        console.log(`[safety] resumed`);
+        return { ok: true, halted: false };
+    });
+    // ── Allocations · 페르소나별 배정 자본 (SPEC-26) ──
+    // GET  /api/allocations           · 전체
+    // POST /api/allocations           · body: { slug, krw } 한 페르소나 set
+    // DELETE /api/allocations/:slug   · 한 페르소나 제거
+    app.get("/api/allocations", async () => {
+        const cfg = loadConfig();
+        return { allocations: cfg.allocations ?? {} };
+    });
+    app.post("/api/allocations", async (req, reply) => {
+        const body = (req.body ?? {});
+        if (!body.slug || typeof body.krw !== "number" || body.krw < 0) {
+            reply.code(400);
+            return { ok: false, error: "slug + krw (>=0) 필요" };
+        }
+        const cfg = loadConfig();
+        const updated = { ...cfg, allocations: { ...(cfg.allocations ?? {}), [body.slug]: body.krw } };
+        saveConfig(updated);
+        return { ok: true, allocations: updated.allocations };
+    });
+    app.delete("/api/allocations/:slug", async (req) => {
+        const { slug } = req.params;
+        const cfg = loadConfig();
+        const next = { ...(cfg.allocations ?? {}) };
+        delete next[slug];
+        saveConfig({ ...cfg, allocations: next });
+        return { ok: true, allocations: next };
+    });
+    // ── Subscriptions (구독한 페르소나 목록) ──
+    //
+    // SSoT = server (mulsok-traders.vercel.app) `user_instances` 테이블 (ADR-001 + ADR-009).
+    // 클라이언트는 device_token 으로 server `/api/client/ping` 호출 → subscriptions[] 캐시.
+    //
+    // GET   /api/subscriptions          · { subscriptions, source, lastSync, authenticated, ... }
+    //   - 캐시 우선 응답 + 필요 시 sync trigger (백그라운드)
+    // POST  /api/subscriptions/sync     · 강제 server 재동기화
+    //
+    // ⚠️ POST /api/subscriptions (Mock 추가) 와 DELETE 는 폐기 (사용자가 임의로 추가 못 함).
+    app.get("/api/subscriptions", async (req) => {
+        const cfg = loadConfig();
+        const last = getLastSync();
+        const q = req.query;
+        // fresh=1 이면 즉시 동기화 후 응답
+        if (q.fresh === "1") {
+            const sync = await fetchServerSubscriptions();
+            const cfg2 = loadConfig();
+            return {
+                subscriptions: cfg2.subscriptions ?? [],
+                source: sync.authenticated ? "server" : "cache",
+                lastSync: sync.syncedAt,
+                authenticated: sync.authenticated,
+                userEmail: sync.ping?.user_email ?? null,
+                deviceLabel: sync.ping?.device_label ?? null,
+                details: sync.ping?.subscriptions ?? null,
+                error: sync.error ?? null,
+            };
+        }
+        return {
+            subscriptions: cfg.subscriptions ?? [],
+            source: last?.authenticated ? "server" : "cache",
+            lastSync: last?.syncedAt ?? null,
+            authenticated: last?.authenticated ?? false,
+            userEmail: last?.ping?.user_email ?? null,
+            deviceLabel: last?.ping?.device_label ?? null,
+            details: last?.ping?.subscriptions ?? null,
+            error: last?.error ?? null,
+        };
+    });
+    app.post("/api/subscriptions/sync", async () => {
+        const sync = await fetchServerSubscriptions();
+        const cfg = loadConfig();
+        return {
+            ok: sync.ok,
+            subscriptions: cfg.subscriptions ?? [],
+            authenticated: sync.authenticated,
+            lastSync: sync.syncedAt,
+            userEmail: sync.ping?.user_email ?? null,
+            details: sync.ping?.subscriptions ?? null,
+            error: sync.error ?? null,
+        };
+    });
+    // ── Diary (페르소나 매매 일기) ──
+    //
+    // GET    /api/diary/:slug?date=YYYY-MM-DD   · 특정 날짜 일기 (없으면 404)
+    // GET    /api/diary/:slug/list?limit=30      · 최근 일기 목록 (date · 발췌)
+    // POST   /api/diary/:slug/write              · 오늘 일기 강제 작성 (overwrite)
+    app.get("/api/diary/:slug", async (req, reply) => {
+        const { slug } = req.params;
+        const q = req.query;
+        const date = q.date ?? new Date(Date.now() + 9 * 3600_000).toISOString().slice(0, 10);
+        const d = readDiary(date, slug);
+        if (!d) {
+            reply.code(404);
+            return { ok: false, error: `${date} 의 ${slug} 일기 없음` };
+        }
+        return { ok: true, ...d };
+    });
+    app.get("/api/diary/:slug/list", async (req) => {
+        const { slug } = req.params;
+        const q = req.query;
+        const limit = q.limit ? parseInt(q.limit, 10) : 30;
+        const list = listDiariesForPersona(slug, limit);
+        return {
+            ok: true,
+            diaries: list.map((d) => ({
+                date: d.date,
+                personaSlug: d.personaSlug,
+                writtenAt: d.writtenAt,
+                excerpt: d.body.split("\n").slice(0, 6).join("\n").slice(0, 400),
+                bodyLength: d.body.length,
+            })),
+        };
+    });
+    app.post("/api/diary/:slug/write", async (req, reply) => {
+        const { slug } = req.params;
+        const body = (req.body ?? {});
+        const r = await writeDiary(slug, { overwrite: body.overwrite });
+        if (!r.ok) {
+            reply.code(500);
+            return r;
+        }
+        return r;
+    });
+    // ── Account Status (계좌 종합 상태) ─────────────────────
+    // 사용자 5 항목 검토용 통합 endpoint · 토큰·예수금·보유·미체결·체결 한 번에
+    // GET /api/account/status?symbolCode=005930 (옵션)
+    app.get("/api/account/status", async (req) => {
+        const q = req.query;
+        const cfg = loadConfig();
+        if (cfg.broker.kind !== "kiwoom") {
+            return {
+                ok: false,
+                error: "broker.kind != 'kiwoom' · 설정 탭에서 키움 선택 필요",
+                broker_kind: cfg.broker.kind,
+            };
+        }
+        if (!cfg.broker.appKey || !cfg.broker.appSecret) {
+            return { ok: false, error: "AppKey / SecretKey 미설정" };
+        }
+        const { getAccessToken, getDeposit, getHoldings, getPendingOrders, getExecutions, getOrderableQty } = await import("./broker/kiwoom/index.js");
+        const start = Date.now();
+        // 1. 토큰
+        const tokenRes = await getAccessToken({
+            appKey: cfg.broker.appKey,
+            secretKey: cfg.broker.appSecret,
+            isDemo: cfg.broker.isDemo,
+        });
+        const result = {
+            ok: tokenRes.ok,
+            env: cfg.broker.isDemo ? "demo" : "live",
+            checked_at: new Date().toISOString(),
+            auth: tokenRes.ok
+                ? {
+                    ok: true,
+                    token_preview: tokenRes.data.token.slice(0, 12) + "...",
+                    expires_at: tokenRes.data.expiresAt,
+                    cached: !!tokenRes.meta?.cached,
+                }
+                : { ok: false, error: tokenRes.error },
+        };
+        if (!tokenRes.ok) {
+            result.elapsed_ms = Date.now() - start;
+            return result;
+        }
+        // 2. 병렬 호출 (rate-limiter 가 직렬화)
+        const [depositRes, holdingsRes, pendingRes, execsRes] = await Promise.all([
+            getDeposit(),
+            getHoldings(),
+            getPendingOrders(q.symbolCode),
+            getExecutions(),
+        ]);
+        result.deposit = depositRes.ok
+            ? { ok: true, ...depositRes.data, raw_keys: Object.keys(depositRes.data.raw).slice(0, 10) }
+            : { ok: false, error: depositRes.error };
+        result.holdings = holdingsRes.ok
+            ? {
+                ok: true,
+                count: holdingsRes.data.items.length,
+                totalEvalKrw: holdingsRes.data.totalEvalKrw,
+                totalPnlKrw: holdingsRes.data.totalPnlKrw,
+                totalPnlPct: holdingsRes.data.totalPnlPct,
+                items: holdingsRes.data.items.slice(0, 20),
+            }
+            : { ok: false, error: holdingsRes.error };
+        result.pendingOrders = pendingRes.ok
+            ? { ok: true, count: pendingRes.data.length, items: pendingRes.data.slice(0, 20) }
+            : { ok: false, error: pendingRes.error };
+        result.executionsToday = execsRes.ok
+            ? { ok: true, count: execsRes.data.length, items: execsRes.data.slice(0, 20) }
+            : { ok: false, error: execsRes.error };
+        // 3. 종목 지정 시 주문가능수량
+        if (q.symbolCode) {
+            const oqRes = await getOrderableQty(q.symbolCode);
+            result.orderableQty = oqRes.ok ? { ok: true, ...oqRes.data } : { ok: false, error: oqRes.error };
+        }
+        result.elapsed_ms = Date.now() - start;
+        return result;
+    });
+    // ── Trade Journal (영구 매매 히스토리) ─────────────────
+    // GET /api/journal/events ?from=&to=&persona=&symbol=&type=&search=
+    // GET /api/journal/stats
+    // GET /api/journal/files
+    // GET /api/journal/orders · OrderTracker 활성/이력
+    // GET /api/journal/telemetry · 송신 큐 상태
+    app.get("/api/journal/events", async (req) => {
+        const q = req.query;
+        const events = readEvents({
+            from: q.from,
+            to: q.to,
+            personaSlug: q.persona,
+            symbolCode: q.symbol,
+            eventTypes: q.type ? [q.type] : undefined,
+            textSearch: q.search,
+            limit: q.limit ? parseInt(q.limit, 10) : 200,
+        });
+        return { count: events.length, events };
+    });
+    // GET /api/quote/current/:code · 현재가 (agent 도메인 도구)
+    app.get("/api/quote/current/:code", async (req, reply) => {
+        const { code } = req.params;
+        const cfg = loadConfig();
+        if (cfg.broker.kind !== "kiwoom" || !cfg.broker.appKey || !cfg.broker.appSecret) {
+            reply.code(200);
+            return { ok: false, error: "broker:not_configured", code };
+        }
+        try {
+            const { getCurrentPrice } = await import("./broker/kiwoom/index.js");
+            const res = await getCurrentPrice(code);
+            if (!res.ok) {
+                reply.code(200);
+                return { ok: false, error: res.error ?? "kiwoom:fetch_failed", code };
+            }
+            return { ok: true, code, ...res.data };
+        }
+        catch (e) {
+            reply.code(200);
+            return { ok: false, error: String(e), code };
+        }
+    });
+    // GET /api/quote/daily/:code?days=30
+    //   - 키움 ka10081 일봉 (수정주가) · 60s 캐시 활용
+    //   - 트레이더 dialog 의 캔들차트 표시용
+    //   - kiwoom 미설정 시 ok:false (UI 가 fallback)
+    app.get("/api/quote/daily/:code", async (req, reply) => {
+        const { code } = req.params;
+        const q = req.query;
+        const days = q.days ? Math.max(5, Math.min(120, parseInt(q.days, 10))) : 30;
+        const cfg = loadConfig();
+        if (cfg.broker.kind !== "kiwoom" || !cfg.broker.appKey || !cfg.broker.appSecret) {
+            reply.code(200);
+            return { ok: false, error: "broker:not_configured", code, days, candles: [] };
+        }
+        try {
+            const { getDailyChart } = await import("./broker/kiwoom/index.js");
+            const res = await getDailyChart(code, days);
+            if (!res.ok) {
+                reply.code(200);
+                return { ok: false, error: res.error ?? "kiwoom:fetch_failed", code, days, candles: [] };
+            }
+            // 시간 오름차순 (오래 → 최신) 으로 정렬해서 차트 그리기 쉽게
+            const candles = [...res.data.candles].sort((a, b) => a.date.localeCompare(b.date));
+            return { ok: true, code, days, candles };
+        }
+        catch (e) {
+            reply.code(200);
+            return { ok: false, error: String(e), code, days, candles: [] };
+        }
+    });
+    app.get("/api/journal/stats", async (req) => {
+        const q = req.query;
+        return computeStats({
+            from: q.from,
+            to: q.to,
+            personaSlug: q.persona,
+            symbolCode: q.symbol,
+        });
+    });
+    app.get("/api/journal/files", async () => {
+        return { files: listJournalFiles() };
+    });
+    app.get("/api/journal/orders", async (req) => {
+        const q = req.query;
+        const tracker = getOrderTracker();
+        return {
+            stats: tracker.stats(),
+            orders: tracker.list({
+                symbolCode: q.symbolCode,
+                activeOnly: q.activeOnly === "true",
+            }),
+        };
+    });
+    app.get("/api/journal/telemetry", async () => {
+        return getTelemetry().stats();
+    });
+    // 일별 손익 + 누적 손익 (FIFO 추정)
+    app.get("/api/journal/pnl", async (req) => {
+        const q = req.query;
+        const { computeDailyPnl } = await import("./journal/pnl-stats.js");
+        return computeDailyPnl({
+            from: q.from,
+            to: q.to,
+            personaSlug: q.persona,
+        });
+    });
+    // Backtest replay (과거 decisions 재생)
+    app.get("/api/journal/replay", async (req) => {
+        const q = req.query;
+        const { replayJournal } = await import("./journal/pnl-stats.js");
+        return replayJournal({
+            from: q.from,
+            to: q.to,
+            personaSlug: q.persona,
+        });
+    });
+    app.delete("/api/watchers/:id", async (req, reply) => {
+        const { id } = req.params;
+        const cw = getConditionWatcher();
+        const removed = cw.remove(id, "revoked");
+        if (!removed) {
+            reply.code(404);
+            return { ok: false, error: "watcher not found" };
+        }
+        return { ok: true, id };
+    });
+    /**
+     * SPEC-27 cleanup 도구 — bulk delete (agent 가 중복 정리용).
+     *
+     * DELETE /api/watchers?personaSlug=neoul&symbolCode=014910
+     *   - personaSlug 만: 그 페르소나의 모든 활성 watcher 제거
+     *   - personaSlug + symbolCode: 그 종목의 활성 watcher 만 제거
+     *   - keepIds=wt_xxx,wt_yyy: 이 id 들은 유지 (가장 최근 1개만 살리기 패턴)
+     */
+    app.delete("/api/watchers", async (req, reply) => {
+        const q = req.query;
+        if (!q.personaSlug) {
+            reply.code(400);
+            return { ok: false, error: "personaSlug 필수" };
+        }
+        const cw = getConditionWatcher();
+        const keep = new Set((q.keepIds ?? "").split(",").map((s) => s.trim()).filter(Boolean));
+        const list = cw.list({ personaSlug: q.personaSlug, activeOnly: true });
+        const removed = [];
+        for (const w of list) {
+            if (keep.has(w.id))
+                continue;
+            if (q.symbolCode) {
+                const cfg = w.spec.condition?.config;
+                if (cfg?.symbolCode !== q.symbolCode)
+                    continue;
+            }
+            if (cw.remove(w.id, "revoked"))
+                removed.push(w.id);
+        }
+        return { ok: true, removed, removedCount: removed.length };
+    });
+    // ── Complete · 조립된 prompt 로 실제 LLM 호출 ────────────────
+    // Readiness 와 중복되는 LLM 단독 · Bundle 단독 테스트는 제거 · Complete 만 유지.
+    // device token 은 config 에서 자동 사용 (persona Bearer 인증).
+    const CompleteSchema = z.object({
+        personaSlug: z.string().optional(),
+        /** 명시적 layer3Header (없으면 buildLayer3Header 자동 조합) */
+        layer3Header: z.string().optional(),
+        /** 자동 Layer 3 조합 비활성 (디버깅 시) */
+        skipAutoLayer3: z.boolean().optional(),
+        userQuestion: z.string().default("오늘 무엇을 할지 판단해줘."),
+        maxTokens: z.number().int().positive().optional(),
+    });
+    app.post("/api/test/complete", async (req, reply) => {
+        const parsed = CompleteSchema.safeParse(req.body ?? {});
+        if (!parsed.success) {
+            reply.code(400);
+            return { ok: false, error: "스키마 오류", issues: parsed.error.issues };
+        }
+        const cfg = loadConfig();
+        const prov = createLlmProvider(cfg);
+        if (!prov) {
+            reply.code(400);
+            return { ok: false, error: "provider=none · 설정 페이지에서 먼저 선택" };
+        }
+        try {
+            // 1) common 로드
+            const common = await fetchCommonBundle(SERVER_BASE_URL);
+            // 2) persona 선택 시 함께 조립 · device token 으로 Bearer 인증
+            let personaBody = "";
+            if (parsed.data.personaSlug) {
+                const persona = await fetchPersonaBundle(SERVER_BASE_URL, parsed.data.personaSlug, cfg.auth?.deviceToken);
+                personaBody = persona.bundle.body;
+            }
+            // Layer 3 자동 조합 (보유/관심/lessons/지수)
+            let layer3Header = parsed.data.layer3Header;
+            if (!layer3Header && !parsed.data.skipAutoLayer3 && parsed.data.personaSlug) {
+                try {
+                    layer3Header = await buildLayer3Header({ personaSlug: parsed.data.personaSlug });
+                }
+                catch (e) {
+                    console.warn("[/api/test/complete] buildLayer3Header 실패 · 무시:", e);
+                }
+            }
+            // Layer 3 patches 자동 reload (Coach 가 출력한 markdown 파일들)
+            const layer3Patches = parsed.data.personaSlug
+                ? loadActivePatches(parsed.data.personaSlug)
+                : undefined;
+            const systemPrompt = assembleFullPrompt({
+                layer1: common.bundle.body,
+                layer2: personaBody || "# Layer 2 미선택 · 일반 Q&A",
+                layer3Header,
+                layer3Patches: layer3Patches || undefined,
+            });
+            const res = await prov.complete({
+                systemPrompt,
+                userPrompt: parsed.data.userQuestion,
+                maxTokens: parsed.data.maxTokens ?? 1024,
+            });
+            // Decision journal (LLM 응답 텍스트는 reasoning 으로 취급 · 구조화 파싱은 클라이언트 책임)
+            if (parsed.data.personaSlug) {
+                logDecision({
+                    personaSlug: parsed.data.personaSlug,
+                    llmContext: {
+                        reasoning: res.text.slice(0, 1000),
+                        tokens: res.usage,
+                        model: res.model,
+                    },
+                });
+            }
+            return {
+                ok: true,
+                result: res,
+                assembled_length: systemPrompt.length,
+                layer3_auto: !!layer3Header && !parsed.data.layer3Header,
+            };
+        }
+        catch (e) {
+            reply.code(500);
+            return { ok: false, error: String(e) };
+        }
+    });
+    /* ════════════════════════════════════════════════════════════
+     * 키움 확장 API · 유니버스 · 지수 · 투자자 · 테마 · 계좌 심화
+     * ════════════════════════════════════════════════════════════ */
+    // ── 유니버스 (ka10099) ──────────────────────────────────────
+    app.get("/api/universe", async (req) => {
+        const q = req.query;
+        const market = (q.market ?? "kospi");
+        const r = await getStockUniverse(market);
+        return r;
+    });
+    app.get("/api/universe/standard", async () => {
+        return await getStandardUniverse();
+    });
+    // ── 시장 지수 (ka20003) ─────────────────────────────────────
+    app.get("/api/index/:market", async (req) => {
+        const { market } = req.params;
+        return await getMarketIndex(market);
+    });
+    app.get("/api/sector/indices/:market", async (req) => {
+        const { market } = req.params;
+        return await getAllSectorIndices(market);
+    });
+    app.get("/api/sector/codes", async (req) => {
+        const q = req.query;
+        return await getSectorCodes(q.market ?? "kospi");
+    });
+    // ── 투자자 동향 (ka10008/09/131) ────────────────────────────
+    app.get("/api/investor/foreign/:code", async (req) => {
+        const { code } = req.params;
+        const q = req.query;
+        return await getForeignActivity(code, q.limit ? Number(q.limit) : 20);
+    });
+    app.get("/api/investor/institution/:code", async (req) => {
+        const { code } = req.params;
+        return await getInstitutionActivity(code);
+    });
+    app.get("/api/investor/continuous", async (req) => {
+        const q = req.query;
+        return await getContinuousInvestorActivity({
+            period: q.period,
+            market: q.market,
+            amountOrQty: q.amountOrQty,
+            startDate: q.startDate,
+            endDate: q.endDate,
+        });
+    });
+    // ── 랭킹 확장 (ka10023 거래량급증 · ka10031 전일거래량상위) ─
+    app.get("/api/ranking/volume-surge", async (req) => {
+        const q = req.query;
+        return await getVolumeSurgeRanking({
+            market: q.market,
+            sort: q.sort,
+            timeBasis: q.timeBasis,
+            minuteWindow: q.minuteWindow,
+            minVolume: q.minVolume,
+            stockCondition: q.stockCondition,
+            priceCondition: q.priceCondition,
+            limit: q.limit ? Number(q.limit) : undefined,
+        });
+    });
+    app.get("/api/ranking/yesterday-volume", async (req) => {
+        const q = req.query;
+        return await getYesterdayVolumeRanking({
+            market: q.market,
+            kind: q.kind,
+            rankStart: q.rankStart ? Number(q.rankStart) : undefined,
+            rankEnd: q.rankEnd ? Number(q.rankEnd) : undefined,
+        });
+    });
+    // ── 일별거래상세 / 일별주가 (ka10015/ka10086) ───────────────
+    app.get("/api/detail/daily-trade/:code", async (req) => {
+        const { code } = req.params;
+        const q = req.query;
+        return await getDailyTradeDetail(code, q.startDate);
+    });
+    app.get("/api/detail/daily-price/:code", async (req) => {
+        const { code } = req.params;
+        const q = req.query;
+        return await getDailyStockPrice(code, q.queryDate, q.displayKind);
+    });
+    // ── 테마 (ka90001/ka90002) ──────────────────────────────────
+    app.get("/api/themes", async (req) => {
+        const q = req.query;
+        return await listThemeGroups({
+            queryKind: q.queryKind,
+            symbolCode: q.symbolCode,
+            daysAgo: q.daysAgo ? Number(q.daysAgo) : undefined,
+            themeName: q.themeName,
+            sort: q.sort,
+        });
+    });
+    app.get("/api/themes/:groupCode", async (req) => {
+        const { groupCode } = req.params;
+        const q = req.query;
+        return await getThemeMembers(groupCode, q.daysAgo ? Number(q.daysAgo) : 10);
+    });
+    // ── 계좌 심화 (kt00004/05/17 · ka10085 · ka10170) ──────────
+    app.get("/api/account/assessment", async (req) => {
+        const q = req.query;
+        return await getAccountAssessment(q.excludeDelisted === "true");
+    });
+    app.get("/api/account/execution-balance", async () => {
+        return await getExecutionBalance();
+    });
+    app.get("/api/account/daily-status", async () => {
+        return await getAccountDailyStatus();
+    });
+    app.get("/api/account/profit-rate", async (req) => {
+        const q = req.query;
+        return await getAccountProfitRate(q.market ?? "unified");
+    });
+    app.get("/api/account/trade-diary", async (req) => {
+        const q = req.query;
+        return await getTradeDiary({
+            baseDate: q.baseDate,
+            kind: q.kind,
+            cashCredit: q.cashCredit,
+        });
+    });
+    /* ════════════════════════════════════════════════════════════
+     * 로컬 유니버스 DB + 배치 + 스크리너
+     * ════════════════════════════════════════════════════════════ */
+    app.get("/api/local/universe/stats", async (req) => {
+        const q = req.query;
+        const count = countUniverse(q.market);
+        const meta = getSyncMeta("universe");
+        return { ok: true, count, meta };
+    });
+    app.get("/api/local/universe", async (req) => {
+        const q = req.query;
+        const rows = listUniverse({ market: q.market, limit: q.limit ? Number(q.limit) : 50 });
+        return { ok: true, count: rows.length, items: rows };
+    });
+    /**
+     * Watchers 테이블 vacuum (P1-4 보강 · 수동 호출).
+     *
+     * - 기본 30일+ 된 non-active row (status='triggered'/'expired'/'revoked') 자동 정리
+     * - status='active' row 는 절대 안 건드림 (운영 중 안전)
+     * - boot 시 자동 1회 호출되지만, 사용자가 수동 호출 가능 (대시보드 「누적 정리」 버튼 등)
+     *
+     * Body: { days?: number } (기본 30 · 1 이상)
+     */
+    app.post("/api/local/vacuum", async (req, reply) => {
+        const body = (req.body ?? {});
+        const days = body.days ?? 30;
+        if (!Number.isFinite(days) || days < 1) {
+            reply.code(400);
+            return { ok: false, error: "days 는 1 이상 정수" };
+        }
+        try {
+            const before = watchersTableStats();
+            const removed = vacuumWatchersOlderThan(days);
+            const after = watchersTableStats();
+            return {
+                ok: true,
+                days,
+                removed,
+                before,
+                after,
+            };
+        }
+        catch (e) {
+            reply.code(500);
+            return { ok: false, error: String(e) };
+        }
+    });
+    app.post("/api/local/sync", async (req, reply) => {
+        const body = (req.body ?? {});
+        try {
+            const r = await runUniverseSync({
+                maxCodes: body.maxCodes ?? 50,
+                candleDays: body.candleDays ?? 120,
+                targetCodes: body.targetCodes,
+            });
+            return { ok: true, result: r };
+        }
+        catch (e) {
+            reply.code(500);
+            return { ok: false, error: String(e) };
+        }
+    });
+    /**
+     * 너울 양음양 타겟 배치:
+     * ka10031 전일 거래량 상위 (KOSPI + KOSDAQ) + 현재 보유 종목 → 일봉 배치.
+     * D-1 장대양봉 + 대량거래 후보 중심의 경량 배치. 1~2 분 소요.
+     */
+    app.post("/api/local/sync/yinyang", async (req, reply) => {
+        const body = (req.body ?? {});
+        const candleDays = body.candleDays ?? 120;
+        try {
+            const [kospiVol, kosdaqVol, holdingsRes] = await Promise.all([
+                import("./broker/kiwoom/index.js").then((m) => m.getYesterdayVolumeRanking({ market: "kospi", kind: "volume", rankStart: 0, rankEnd: 100 })),
+                import("./broker/kiwoom/index.js").then((m) => m.getYesterdayVolumeRanking({ market: "kosdaq", kind: "volume", rankStart: 0, rankEnd: 100 })),
+                import("./broker/kiwoom/index.js").then((m) => m.getHoldings()),
+            ]);
+            const codes = new Set();
+            if (kospiVol.ok)
+                for (const r of kospiVol.data)
+                    codes.add(r.symbolCode);
+            if (kosdaqVol.ok)
+                for (const r of kosdaqVol.data)
+                    codes.add(r.symbolCode);
+            if (holdingsRes.ok)
+                for (const h of holdingsRes.data.items)
+                    codes.add(h.symbolCode.replace(/^A/, ""));
+            const r = await runUniverseSync({
+                candleDays,
+                targetCodes: Array.from(codes),
+            });
+            return {
+                ok: true,
+                targetCodes: Array.from(codes),
+                targetCount: codes.size,
+                result: r,
+            };
+        }
+        catch (e) {
+            reply.code(500);
+            return { ok: false, error: String(e) };
+        }
+    });
+    app.post("/api/local/screener", async (req, reply) => {
+        const body = (req.body ?? {});
+        try {
+            const r = await runScreener(body);
+            return { ok: true, result: r };
+        }
+        catch (e) {
+            reply.code(500);
+            return { ok: false, error: String(e) };
+        }
+    });
+    /* ════════════════════════════════════════════════════════════
+     * WebSocket · 조건검색 (선택 기능 · 파워유저용)
+     * ════════════════════════════════════════════════════════════ */
+    app.get("/api/ws/status", async () => {
+        const ws = getKiwoomWs();
+        return { ok: true, status: ws.getStatus(), ready: ws.isReady() };
+    });
+    app.post("/api/ws/connect", async (req, reply) => {
+        const ws = getKiwoomWs();
+        const r = await ws.connect();
+        if (!r.ok) {
+            reply.code(500);
+            return { ok: false, error: r.error };
+        }
+        return { ok: true, status: ws.getStatus() };
+    });
+    app.post("/api/ws/disconnect", async () => {
+        const ws = getKiwoomWs();
+        await ws.disconnect();
+        return { ok: true };
+    });
+    app.get("/api/ws/conditions", async () => {
+        return await listConditions();
+    });
+    app.get("/api/ws/conditions/:seq/run", async (req) => {
+        const { seq } = req.params;
+        return await requestCondition({ seq });
+    });
+}
+//# sourceMappingURL=routes.js.map