diff --git a/skills/kuns9/trading-upbit-skill/.env.example b/skills/kuns9/trading-upbit-skill/.env.example
new file mode 100644
index 0000000000..fa677b9adc
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/.env.example
@@ -0,0 +1,9 @@
+# Upbit API Keys
+UPBIT_OPEN_API_ACCESS_KEY=your_access_key_here
+UPBIT_OPEN_API_SECRET_KEY=your_secret_key_here
+
+# Bot Settings
+PRICE_CHECK_INTERVAL=10000
+TARGET_PROFIT=0.05
+STOP_LOSS=-0.05
+AUTO_TRADE=false
\ No newline at end of file
diff --git a/skills/kuns9/trading-upbit-skill/README.md b/skills/kuns9/trading-upbit-skill/README.md
new file mode 100644
index 0000000000..128ec8ea61
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/README.md
@@ -0,0 +1,68 @@
+# Upbit Trading Engine 🚀
+
+안정성과 확장성을 최우선으로 설계된 업비트 자동 매매 엔진입니다. SKILLS 규격을 준수하여 체계적으로 코드를 관리합니다.
+
+## 주요 특징
+
+- 🏗️ **SKILLS 구조**: `scripts/`(로직), `resources/`(데이터), `backup/`(백업)으로 체기적 관리
+- 🛡️ **견고한 예외 처리**: `upbitClient.js`를 통한 중앙 집중식 에러 관리 및 **429(Rate Limit) 자동 재시도**
+- 🔍 **다이나믹 스케너**: 업비트의 모든 KRW 마켓을 실시간으로 자동 탐색하여 기회 포착
+- 🚀 **이중 확인 전략**: 1일봉 돌파 신호를 60분봉 추세로 검증하는 Multi-Timeframe 분석
+- 🔄 **상태 머신**: `FLAT` -> `ENTRY_PENDING` -> `OPEN` -> `EXIT_PENDING` -> `CLOSED` 상태 관리
+
+## 시작하기
+
+### 설치
+
+```bash
+# 저장소 복제
+git clone <repository-url>
+cd trading-upbit-skill
+
+# 의존성 설치
+npm install
+```
+
+### 설정
+
+1. [Upbit API 키 발급](https://upbit.com/mypage/open_api_management)
+2. `.env` 파일 설정:
+   ```bash
+   cp .env.example .env
+   # .env 파일을 열어 발급받은 Access Key와 Secret Key를 입력하세요.
+   ```
+
+### 실행
+
+시스템은 모니터와 이벤트 워커 두 가지 프로세스로 구성됩니다. 별도의 터미널에서 각각 실행해 주세요.
+
+```bash
+# 마켓 스캔 및 포지션 감시
+node scripts/workers/monitor.js
+
+# 이벤트 처리 및 매매 실행
+node scripts/workers/eventWorker.js
+```
+
+## 디렉토리 구조
+
+- `scripts/`: 핵심 실행 로직 및 모듈
+  - `workers/`: 배경에서 동작하는 작업자 프로세스
+  - `execution/`: 매매 실행 엔진
+  - `risk/`: 리스크 관리 필터
+  - `state/`: 포지션 및 상태 관리
+- `resources/`: `positions.json`, `events.json` 등 동적 데이터 저장소
+- `backup/`: 이전 코드 및 로그 백업
+- `examples/`: 참고용 예제 코드
+
+## Core Scripts
+
+- `scripts/workers/monitor.js`: 동적 마켓 스캔 및 포지션 감시
+- `scripts/workers/eventWorker.js`: 이벤트 전파 및 처리 프로세서
+- `scripts/execution/tradeExecutor.js`: 상태 전이 기반 매매 엔진
+- `scripts/risk/riskManager.js`: 리스크 평가 및 사이징 필터
+- `scripts/state/positionsRepo.js`: 상태 머신 영속성 관리
+
+## 라이선스
+
+이 프로젝트는 ISC 라이선스를 따릅니다.
diff --git a/skills/kuns9/trading-upbit-skill/SKILL.md b/skills/kuns9/trading-upbit-skill/SKILL.md
new file mode 100644
index 0000000000..3e1dbb29a5
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: Upbit Trading Engine
+description: 안정성과 확장성을 최우선으로 설계된 업비트 자동 매매 엔진 (SKILLS 규격 준수)
+metadata:
+  clawdbot:
+    requires:
+      env:
+        - UPBIT_OPEN_API_ACCESS_KEY
+        - UPBIT_OPEN_API_SECRET_KEY
+        - PRICE_CHECK_INTERVAL
+        - TARGET_PROFIT
+        - STOP_LOSS
+        - AUTO_TRADE
+files:
+  - "skill.js"
+  - "scripts/**"
+  - "resources/**"
+homepage: "https://github.com/sgyeo/trading-upbit-skill"
+---
+
+# Upbit Trading Engine 🚀
+
+안정성과 확장성을 최우선으로 설계된 업비트 자동 매매 엔진입니다. (SKILLS 규격 준수)
+
+## Key Features
+
+- 🏗️ **SKILLS 구조**: `scripts/`(로직), `resources/`(데이터), `backup/`(백업)으로 체계적 관리
+- 🛡️ **견고한 예외 처리**: `upbitClient.js`를 통한 중앙 집중식 에러 관리 및 **429(Rate Limit) 자동 재시도**
+- 🔍 **다이나믹 스케너**: 업비트의 모든 KRW 마켓을 실시간으로 자동 탐색하여 기회 포착
+- 🚀 **이중 확인 전략**: 1일봉 돌파 신호를 60분봉 추세로 검증하는 Multi-Timeframe 분석
+- 🔄 **상태 머신**: `FLAT` -> `ENTRY_PENDING` -> `OPEN` -> `EXIT_PENDING` -> `CLOSED` 상태 관리
+
+## Setup
+
+1. [Upbit API 키 발급](https://upbit.com/mypage/open_api_management)
+2. 환경변수 설정:
+```bash
+cp .env.example .env
+```
+
+3. 실행:
+```bash
+# 별도의 터미널에서 각각 실행
+node scripts/workers/monitor.js
+node scripts/workers/eventWorker.js
+```
+
+## Directory Structure
+
+- `scripts/`: 실행 로직 및 핵심 모듈
+- `resources/`: `positions.json`, `events.json` 등 동적 데이터
+- `backup/`: 이전 코드 및 로그 백업
+- `examples/`: 참고용 예제 및 설정
+
+## Core Scripts
+
+- `scripts/workers/monitor.js`: 동적 마켓 스캔 및 포지션 감시
+- `scripts/workers/eventWorker.js`: 이벤트 전파 및 처리 프로세서
+- `scripts/execution/tradeExecutor.js`: 상태 전이 기반 매매 엔진
+- `scripts/risk/riskManager.js`: 리스크 평가 및 사이징 필터
+- `scripts/state/positionsRepo.js`: 상태 머신 영속성 관리
diff --git a/skills/kuns9/trading-upbit-skill/package.json b/skills/kuns9/trading-upbit-skill/package.json
new file mode 100644
index 0000000000..ed2356c436
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "trading-upbit-skill",
+  "version": "1.0.0",
+  "description": "",
+  "main": "balance.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "axios": "^1.13.5",
+    "dotenv": "^17.3.1",
+    "jsonwebtoken": "^9.0.3",
+    "uuid": "^13.0.0"
+  }
+}
\ No newline at end of file
diff --git a/skills/kuns9/trading-upbit-skill/scripts/data/marketData.js b/skills/kuns9/trading-upbit-skill/scripts/data/marketData.js
new file mode 100644
index 0000000000..a76deea825
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/data/marketData.js
@@ -0,0 +1,82 @@
+const { request } = require('./api-client');
+
+/**
+ * 업비트 공용 시세 조회 모듈 (market.js)
+ */
+
+const BASE_URL = 'https://api.upbit.com/v1';
+
+/**
+ * 마켓 코드 조회 (전체 종목 리스트)
+ */
+async function getMarkets(filterKRW = true) {
+    const data = await request({
+        method: 'get',
+        url: `${BASE_URL}/market/all?isDetails=false`
+    });
+
+    return filterKRW ? data.filter(m => m.market.startsWith('KRW-')) : data;
+}
+
+/**
+ * 캔들 조회 (통합 함수)
+ */
+async function getCandles(unit, market, count = 1, subUnit = 1) {
+    let url = `${BASE_URL}/candles/${unit}`;
+    if (unit === 'minutes') {
+        url += `/${subUnit}`;
+    }
+
+    return request({
+        method: 'get',
+        url,
+        params: { market, count }
+    });
+}
+
+/**
+ * 현재가 정보 조회 (Ticker)
+ */
+async function getTickers(markets) {
+    const marketsStr = Array.isArray(markets) ? markets.join(',') : markets;
+    return request({
+        method: 'get',
+        url: `${BASE_URL}/ticker`,
+        params: { markets: marketsStr }
+    });
+}
+
+/**
+ * 호가 조회 (Orderbook)
+ */
+async function getOrderbooks(markets) {
+    const marketsStr = Array.isArray(markets) ? markets.join(',') : markets;
+    return request({
+        method: 'get',
+        url: `${BASE_URL}/orderbook`,
+        params: { markets: marketsStr }
+    });
+}
+
+module.exports = {
+    getMarkets,
+    getCandles,
+    getTickers,
+    getOrderbooks
+};
+
+// 테스트 코드
+if (require.main === module) {
+    (async () => {
+        try {
+            console.log('--- Market Module Test ---');
+            const btcTicker = await getTickers('KRW-BTC');
+            console.log('BTC Ticker:', btcTicker[0].trade_price);
+
+            const krwMarkets = await getMarkets();
+            console.log('KRW Markets Count:', krwMarkets.length);
+        } catch (err) {
+            console.error('Test Failed:', err.message);
+        }
+    })();
+}
diff --git a/skills/kuns9/trading-upbit-skill/scripts/execution/orderService.js b/skills/kuns9/trading-upbit-skill/scripts/execution/orderService.js
new file mode 100644
index 0000000000..b63804f3e9
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/execution/orderService.js
@@ -0,0 +1,69 @@
+/**
+ * 주문 서비스 (orderService.js)
+ * - 시장가 매수(Price) / 시장가 매도(Market) 최적화
+ * - UpbitClient를 이용한 실제 API 호출
+ */
+
+const { Logger } = require('./upbitClient');
+
+class OrderService {
+    constructor(upbitClient) {
+        this.client = upbitClient;
+    }
+
+    /**
+     * 시장가 매수 (Entry)
+     * @param {string} market - 마켓 코드
+     * @param {number} totalKRW - 총 주문 금액
+     */
+    async placeMarketBuy(market, totalKRW) {
+        Logger.info(`[BUY] 시장가 매수 시도: ${market} - ${totalKRW.toLocaleString()} KRW`);
+
+        // 시장가 매수는 ord_type: 'price'
+        // volume은 없어야 하며 price가 총 KRW 금액이 됨
+        const orderData = {
+            market,
+            side: 'bid',
+            price: totalKRW.toString(),
+            ord_type: 'price'
+        };
+
+        return this.client.request('POST', '/orders', orderData);
+    }
+
+    /**
+     * 시장가 매도 (Exit)
+     * @param {string} market - 마켓 코드
+     * @param {number} volume - 매도 수량
+     */
+    async placeMarketSell(market, volume) {
+        Logger.info(`[SELL] 시장가 매도 시도: ${market} - ${volume}`);
+
+        // 시장가 매도는 ord_type: 'market'
+        // price는 없어야 하며 volume이 수량이 됨
+        const orderData = {
+            market,
+            side: 'ask',
+            volume: volume.toString(),
+            ord_type: 'market'
+        };
+
+        return this.client.request('POST', '/orders', orderData);
+    }
+
+    /**
+     * 주문 조회
+     */
+    async getOrder(uuid) {
+        return this.client.request('GET', '/order', {}, { uuid });
+    }
+
+    /**
+     * 주문 취소
+     */
+    async cancelOrder(uuid) {
+        return this.client.request('DELETE', '/order', {}, { uuid });
+    }
+}
+
+module.exports = OrderService;
diff --git a/skills/kuns9/trading-upbit-skill/scripts/execution/tradeExecutor.js b/skills/kuns9/trading-upbit-skill/scripts/execution/tradeExecutor.js
new file mode 100644
index 0000000000..d3c654e05e
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/execution/tradeExecutor.js
@@ -0,0 +1,69 @@
+/**
+ * 통합 매매 실행자 (tradeExecutor.js)
+ * - 리스크 관리 확인
+ * - 주문 실행 및 상태 전이 (PositionsRepo 활용)
+ */
+
+const { Logger } = require('./upbitClient');
+const riskManager = require('../risk/riskManager');
+const positionsRepo = require('../state/positionsRepo');
+
+class TradeExecutor {
+    constructor(orderService) {
+        this.orderService = orderService;
+    }
+
+    async execute(event) {
+        Logger.info(`[EXECUTOR] 이벤트 처리 시작: ${event.type} - ${event.market}`);
+
+        try {
+            // 1. 리스크 평가
+            const riskResult = await riskManager.evaluate(this.orderService.client, event);
+            if (!riskResult.allow) {
+                Logger.warn(`[SKIP] 리스크 필터에 의해 생략됨: ${riskResult.reason} (${riskResult.detail || ''})`);
+                return false;
+            }
+
+            // 2. 상태별 작업 및 전이
+            if (event.type === 'BUY_SIGNAL') {
+                // 이미 진행 중인 포지션이 있는지 확인 (중복 주문 방지)
+                const data = await positionsRepo.load();
+                if (data.positions.some(p => p.market === event.market && (p.state === 'OPEN' || p.state === 'ENTRY_PENDING'))) {
+                    Logger.warn(`[SKIP] 이미 해당 마켓의 포지션이 존재하여 생략함: ${event.market}`);
+                    return false;
+                }
+
+                // 상태 전이: FLAT -> ENTRY_PENDING
+                await positionsRepo.createEntryPending(event.market, event.meta?.strategy || 'unknown', riskResult.budgetKRW);
+
+                // 실제 주문 실행 (시장가 매수)
+                const orderResult = await this.orderService.placeMarketBuy(event.market, riskResult.budgetKRW);
+                Logger.info(`[DONE] 시장가 매수 주문 완료: ${orderResult.uuid}`);
+
+                // 상태 전이: ENTRY_PENDING -> OPEN (실제 체결 확인은 FillWatcher에서 보완)
+                await positionsRepo.updateToOpen(event.market, orderResult);
+                return true;
+            }
+
+            if (event.type === 'TARGET_HIT' || event.type === 'STOPLOSS_HIT') {
+                // 상태 전이: OPEN -> EXIT_PENDING
+                await positionsRepo.updateToExitPending(event.market, event.type);
+
+                // 실제 주문 실행 (시장가 매도)
+                const orderResult = await this.orderService.placeMarketSell(event.market, riskResult.volume);
+                Logger.info(`[DONE] 시장가 매도 주문 완료: ${orderResult.uuid}`);
+
+                // 상태 전이: EXIT_PENDING -> CLOSED
+                await positionsRepo.updateToClosed(event.market, orderResult);
+                return true;
+            }
+
+            return false;
+        } catch (err) {
+            Logger.error(`Trade Execution Error: ${err.message}`);
+            throw err;
+        }
+    }
+}
+
+module.exports = TradeExecutor;
diff --git a/skills/kuns9/trading-upbit-skill/scripts/execution/upbitClient.js b/skills/kuns9/trading-upbit-skill/scripts/execution/upbitClient.js
new file mode 100644
index 0000000000..8ae0160ad9
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/execution/upbitClient.js
@@ -0,0 +1,102 @@
+const axios = require('axios');
+const jwt = require('jsonwebtoken');
+const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
+const querystring = require('querystring');
+
+/**
+ * Upbit 클라이언트 (upbitClient.js)
+ * - 인증 헤더 생성
+ * - Rate Limit (429) 자동 재시도
+ * - 표준 에러 로깅
+ */
+
+const Logger = {
+    info: (msg) => console.log(`[${new Date().toLocaleString()}] [UPBIT-CLIENT] ${msg}`),
+    warn: (msg) => console.warn(`[${new Date().toLocaleString()}] [UPBIT-WARN] ${msg}`),
+    error: (msg) => console.error(`[${new Date().toLocaleString()}] [UPBIT-ERR] ${msg}`),
+};
+
+class UpbitClient {
+    constructor(accessKey, secretKey) {
+        this.accessKey = accessKey;
+        this.secretKey = secretKey;
+        this.baseUrl = 'https://api.upbit.com/v1';
+
+        this.api = axios.create({
+            baseURL: this.baseUrl,
+            timeout: 10000,
+            headers: { 'Content-Type': 'application/json' } // 권장되는 JSON 헤더
+        });
+
+        this._setupInterceptors();
+    }
+
+    _createAuthHeader(queryParams = {}) {
+        const payload = {
+            access_key: this.accessKey,
+            nonce: uuidv4(),
+        };
+
+        const query = querystring.stringify(queryParams);
+        if (query) {
+            const hash = crypto.createHash('sha512');
+            const queryHash = hash.update(query, 'utf-8').digest('hex');
+            payload.query_hash = queryHash;
+            payload.query_hash_alg = 'SHA512';
+        }
+
+        const token = jwt.sign(payload, this.secretKey, { algorithm: 'HS512' });
+        return `Bearer ${token}`;
+    }
+
+    _setupInterceptors() {
+        this.api.interceptors.response.use(
+            (response) => response,
+            async (error) => {
+                const { config, response } = error;
+                if (response && response.status === 429) {
+                    const remainingSec = parseFloat(response.headers['remaining-second']) || 1;
+                    const waitTime = (remainingSec + 0.5) * 1000;
+                    Logger.warn(`Rate Limit(429) 도달. ${waitTime}ms 후 재시도...`);
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                    return this.api(config);
+                }
+
+                const upbitError = response?.data?.error;
+                if (upbitError) {
+                    Logger.error(`API Error [${response.status}] (${upbitError.name}): ${upbitError.message}`);
+                } else {
+                    Logger.error(`Network/HTTP Error: ${error.message}`);
+                }
+                return Promise.reject(error);
+            }
+        );
+    }
+
+    async request(method, url, data = {}, params = {}) {
+        const isAuthRequest = url.startsWith('/orders') || url.startsWith('/accounts') || url.startsWith('/order');
+        const headers = {};
+
+        if (isAuthRequest) {
+            // POST의 경우 data가 query_hash 대상, GET의 경우 params가 대상
+            const authParams = method.toLowerCase() === 'get' ? params : data;
+            headers.Authorization = this._createAuthHeader(authParams);
+        }
+
+        try {
+            const response = await this.api({
+                method,
+                url,
+                data: method.toLowerCase() === 'get' ? undefined : data,
+                params,
+                headers
+            });
+            return response.data;
+        } catch (err) {
+            throw err;
+        }
+    }
+}
+
+module.exports = { UpbitClient, Logger };
diff --git a/skills/kuns9/trading-upbit-skill/scripts/indicators/indicators.js b/skills/kuns9/trading-upbit-skill/scripts/indicators/indicators.js
new file mode 100644
index 0000000000..5edbc7a0f5
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/indicators/indicators.js
@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+/**
+ * 기술적 지표 계산 모듈 (V2 - 최적화 및 표준화 버전)
+ */
+
+/**
+ * 데이터 정제 유틸리티
+ * @param {any[]} data - 입력 데이터
+ * @param {Object} options - { newestFirst: false }
+ */
+function sanitizePrices(data, options = {}) {
+  if (!Array.isArray(data)) return [];
+
+  const { newestFirst = false } = options;
+  let prices = data.map(v => {
+    if (typeof v === 'object' && v !== null && 'close' in v) return Number(v.close);
+    return Number(v);
+  });
+
+  // NaN, Infinity 제거
+  prices = prices.filter(v => Number.isFinite(v));
+
+  if (newestFirst) {
+    prices.reverse();
+  }
+
+  return prices;
+}
+
+/**
+ * 캔들 데이터 정제 유틸리티 (ATR 등용)
+ */
+function sanitizeCandles(data, options = {}) {
+  if (!Array.isArray(data)) return [];
+  const { newestFirst = false } = options;
+
+  let candles = data.map(c => ({
+    high: Number(c.high),
+    low: Number(c.low),
+    close: Number(c.close),
+    open: Number(c.open)
+  })).filter(c =>
+    Number.isFinite(c.high) &&
+    Number.isFinite(c.low) &&
+    Number.isFinite(c.close)
+  );
+
+  if (newestFirst) {
+    candles.reverse();
+  }
+  return candles;
+}
+
+/**
+ * RSI (Relative Strength Index)
+ */
+function calculateRSI(data, period = 14, options = {}) {
+  const prices = sanitizePrices(data, options);
+  if (prices.length < period + 1) return { value: null };
+
+  let gains = 0;
+  let losses = 0;
+
+  for (let i = 1; i <= period; i++) {
+    const change = prices[i] - prices[i - 1];
+    if (change > 0) gains += change;
+    else losses -= change;
+  }
+
+  let avgGain = gains / period;
+  let avgLoss = losses / period;
+
+  for (let i = period + 1; i < prices.length; i++) {
+    const change = prices[i] - prices[i - 1];
+    if (change > 0) {
+      avgGain = (avgGain * (period - 1) + change) / period;
+      avgLoss = (avgLoss * (period - 1)) / period;
+    } else {
+      avgGain = (avgGain * (period - 1)) / period;
+      avgLoss = (avgLoss * (period - 1) - change) / period;
+    }
+  }
+
+  if (avgLoss === 0) return { value: 100, meta: { avgGain, avgLoss } };
+  if (avgGain === 0) return { value: 0, meta: { avgGain, avgLoss } };
+
+  const rs = avgGain / avgLoss;
+  const rsi = 100 - (100 / (1 + rs));
+  return { value: rsi, meta: { avgGain, avgLoss } };
+}
+
+/**
+ * EMA (지수이동평균) - O(N)
+ */
+function calculateEMA(data, period, options = {}) {
+  const prices = sanitizePrices(data, options);
+  const { returnSeries = false } = options;
+  if (prices.length < period) return returnSeries ? [] : { value: null };
+
+  const multiplier = 2 / (period + 1);
+  let ema = prices.slice(0, period).reduce((a, b) => a + b, 0) / period;
+  const series = [ema];
+
+  for (let i = period; i < prices.length; i++) {
+    ema = (prices[i] - ema) * multiplier + ema;
+    if (returnSeries) series.push(ema);
+  }
+
+  return returnSeries ? series : { value: ema };
+}
+
+/**
+ * MACD (Moving Average Convergence Divergence) - O(N)
+ */
+function calculateMACD(data, fastPeriod = 12, slowPeriod = 26, signalPeriod = 9, options = {}) {
+  const prices = sanitizePrices(data, options);
+  if (prices.length < slowPeriod + signalPeriod) return { value: null };
+
+  const fastEMAs = calculateEMA(prices, fastPeriod, { returnSeries: true });
+  const slowEMAs = calculateEMA(prices, slowPeriod, { returnSeries: true });
+
+  const diff = slowPeriod - fastPeriod;
+  const macdLine = [];
+  for (let i = 0; i < slowEMAs.length; i++) {
+    macdLine.push(fastEMAs[i + diff] - slowEMAs[i]);
+  }
+
+  const signalLineSeries = calculateEMA(macdLine, signalPeriod, { returnSeries: true });
+  const currentMACD = macdLine[macdLine.length - 1];
+  const currentSignal = signalLineSeries[signalLineSeries.length - 1];
+
+  return {
+    value: currentMACD,
+    signal: currentSignal,
+    histogram: currentMACD - currentSignal,
+    meta: { fastPeriod, slowPeriod, signalPeriod }
+  };
+}
+
+/**
+ * Bollinger Bands
+ */
+function calculateBollingerBands(data, period = 20, multiplier = 2, options = {}) {
+  const prices = sanitizePrices(data, options);
+  if (prices.length < period) return { value: null };
+
+  const slice = prices.slice(-period);
+  const ma = slice.reduce((a, b) => a + b, 0) / period;
+  const squaredDiffs = slice.map(p => Math.pow(p - ma, 2));
+  const variance = squaredDiffs.reduce((a, b) => a + b, 0) / period;
+  const stdDev = Math.sqrt(variance);
+
+  if (stdDev === 0) {
+    return { value: ma, upper: ma, lower: ma, meta: { stdDev: 0 } };
+  }
+
+  return {
+    value: ma,
+    upper: ma + (multiplier * stdDev),
+    lower: ma - (multiplier * stdDev),
+    meta: { stdDev, period, multiplier }
+  };
+}
+
+/**
+ * ATR (Average True Range)
+ */
+function calculateATR(data, period = 14, options = {}) {
+  const candles = sanitizeCandles(data, options);
+  if (candles.length < period + 1) return { value: null };
+
+  const trs = [];
+  for (let i = 1; i < candles.length; i++) {
+    const tr = Math.max(
+      candles[i].high - candles[i].low,
+      Math.abs(candles[i].high - candles[i - 1].close),
+      Math.abs(candles[i].low - candles[i - 1].close)
+    );
+    trs.push(tr);
+  }
+
+  let atr = trs.slice(0, period).reduce((a, b) => a + b, 0) / period;
+  for (let i = period; i < trs.length; i++) {
+    atr = (atr * (period - 1) + trs[i]) / period;
+  }
+
+  return { value: atr, meta: { period } };
+}
+
+module.exports = {
+  sanitizePrices,
+  sanitizeCandles,
+  calculateRSI,
+  calculateEMA,
+  calculateMACD,
+  calculateBollingerBands,
+  calculateATR
+};
+
+// CLI 및 단위 테스트
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const isJson = args.includes('--json');
+  const newestFirst = args.includes('--newest-first');
+
+  const testPrices = [
+    44, 44.5, 43.5, 44.5, 44, 43.5, 44, 44.5, 44, 43.5,
+    44.5, 45, 45.5, 46, 45.5, 46, 46.5, 47, 46.5, 47,
+    47.5, 48, 48.5, 49, 48.5, 48, 47.5, 47, 46.5, 46,
+    45.5, 45, 44.5, 44, 43.5, 43, 42.5, 42, 41.5, 41
+  ];
+
+  const testCandles = testPrices.map(p => ({ high: p + 1, low: p - 1, close: p }));
+
+  const results = {
+    rsi: calculateRSI(testPrices, 14, { newestFirst }),
+    macd: calculateMACD(testPrices, 12, 26, 9, { newestFirst }),
+    atr: calculateATR(testCandles, 14, { newestFirst }),
+    bb: calculateBollingerBands(testPrices, 20, 2, { newestFirst })
+  };
+
+  if (isJson) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    console.log('=== Indicators V2 Unit Tests ===');
+    console.log('데이터 방향:', newestFirst ? '최신 -> 과거' : '과거 -> 최신');
+    console.log('RSI(14):', results.rsi.value?.toFixed(2));
+    console.log('MACD Line:', results.macd.value?.toFixed(2));
+    console.log('MACD Signal:', results.macd.signal?.toFixed(2));
+    console.log('ATR(14):', results.atr.value?.toFixed(2));
+    console.log('BB Upper:', results.bb.upper?.toFixed(2));
+  }
+}
diff --git a/skills/kuns9/trading-upbit-skill/scripts/risk/riskManager.js b/skills/kuns9/trading-upbit-skill/scripts/risk/riskManager.js
new file mode 100644
index 0000000000..f16ddf0bc7
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/risk/riskManager.js
@@ -0,0 +1,63 @@
+/**
+ * 리스크 관리 모듈 (riskManager.js)
+ * - 잔고 확인 및 주문 가능 여부 판단
+ * - 최소 주문 금액(min_total) 필터
+ * - 사이징 정책
+ */
+
+const { Logger } = require('../execution/upbitClient');
+
+class RiskManager {
+    /**
+     * 주문 실행 전 리스크 검증
+     * @param {Object} upbitClient - UpbitClient 인스턴스
+     * @param {Object} event - 처리하려는 이벤트
+     */
+    async evaluate(upbitClient, event) {
+        try {
+            // 1. 주문 가능 정보 조회 (orders/chance)
+            const chance = await upbitClient.request('GET', '/orders/chance', {}, { market: event.market });
+
+            const bidFee = parseFloat(chance.bid_fee);
+            const askFee = parseFloat(chance.ask_fee);
+            const krwBalance = parseFloat(chance.bid_account.balance);
+            const minTotal = parseFloat(chance.market.bid.min_total); // 최소 주문 금액 (KRW)
+
+            if (event.type === 'BUY_SIGNAL') {
+                const budget = event.budgetKRW || 10000; // 기본 1만원 또는 설정값
+
+                // 잔고 부족 확인
+                if (krwBalance < budget) {
+                    return { allow: false, reason: 'INSUFFICIENT_BALANCE', detail: `잔고부족: ${krwBalance.toLocaleString()} KRW` };
+                }
+
+                // 최소 주문 금액 미달 확인
+                if (budget < minTotal) {
+                    return { allow: false, reason: 'UNDER_MIN_TOTAL', detail: `최소주문금액 미달: ${budget} < ${minTotal}` };
+                }
+
+                return { allow: true, budgetKRW: budget, fee: bidFee };
+            }
+
+            if (event.type === 'TARGET_HIT' || event.type === 'STOPLOSS_HIT') {
+                // 매도의 경우 보유 수량 확인 (accounts)
+                const accounts = await upbitClient.request('GET', '/accounts');
+                const currency = event.market.split('-')[1];
+                const asset = accounts.find(a => a.currency === currency);
+
+                if (!asset || parseFloat(asset.balance) <= 0) {
+                    return { allow: false, reason: 'NO_ASSET_TO_SELL' };
+                }
+
+                return { allow: true, volume: asset.balance, fee: askFee };
+            }
+
+            return { allow: false, reason: 'UNKNOWN_EVENT_TYPE' };
+        } catch (err) {
+            Logger.error(`Risk Evaluation Failed: ${err.message}`);
+            return { allow: false, reason: 'ERROR', detail: err.message };
+        }
+    }
+}
+
+module.exports = new RiskManager();
diff --git a/skills/kuns9/trading-upbit-skill/scripts/state/positionsRepo.js b/skills/kuns9/trading-upbit-skill/scripts/state/positionsRepo.js
new file mode 100644
index 0000000000..a4949c6dc6
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/state/positionsRepo.js
@@ -0,0 +1,89 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * 포지션 저장소 (positionsRepo.js)
+ * - 상태 머신 기반 포지션 관리
+ * - FLAT -> ENTRY_PENDING -> OPEN -> EXIT_PENDING -> CLOSED
+ */
+
+const POSITIONS_FILE = path.join(process.cwd(), 'resources', 'positions.json');
+
+class PositionsRepo {
+    async load() {
+        try {
+            const data = await fs.readFile(POSITIONS_FILE, 'utf8');
+            return JSON.parse(data);
+        } catch (err) {
+            return { positions: [] };
+        }
+    }
+
+    async save(data) {
+        await fs.writeFile(POSITIONS_FILE, JSON.stringify(data, null, 2));
+    }
+
+    /**
+     * 포지션 생성 (FLAT -> ENTRY_PENDING)
+     */
+    async createEntryPending(market, strategy, budget) {
+        const data = await this.load();
+        const newPos = {
+            id: `pos_${Date.now()}`,
+            market,
+            state: 'ENTRY_PENDING',
+            entry: {
+                budgetKRW: budget,
+                createdAt: new Date().toISOString()
+            },
+            meta: { strategy }
+        };
+        data.positions.push(newPos);
+        await this.save(data);
+        return newPos;
+    }
+
+    /**
+     * 진입 완료 업데이트 (ENTRY_PENDING -> OPEN)
+     */
+    async updateToOpen(market, orderResult) {
+        const data = await this.load();
+        const pos = data.positions.find(p => p.market === market && p.state === 'ENTRY_PENDING');
+        if (pos) {
+            pos.state = 'OPEN';
+            pos.entry.orderUuid = orderResult.uuid;
+            pos.entry.avgFillPrice = parseFloat(orderResult.price || 0);
+            pos.entry.openedAt = new Date().toISOString();
+            await this.save(data);
+        }
+    }
+
+    /**
+     * 청산 대기 업데이트 (OPEN -> EXIT_PENDING)
+     */
+    async updateToExitPending(market, reason) {
+        const data = await this.load();
+        const pos = data.positions.find(p => p.market === market && p.state === 'OPEN');
+        if (pos) {
+            pos.state = 'EXIT_PENDING';
+            pos.exit = { reason, triggeredAt: new Date().toISOString() };
+            await this.save(data);
+        }
+    }
+
+    /**
+     * 포지션 종료 (EXIT_PENDING -> CLOSED)
+     */
+    async updateToClosed(market, orderResult) {
+        const data = await this.load();
+        const pos = data.positions.find(p => p.market === market && p.state === 'EXIT_PENDING');
+        if (pos) {
+            pos.state = 'CLOSED';
+            pos.exit.orderUuid = orderResult.uuid;
+            pos.exit.closedAt = new Date().toISOString();
+            await this.save(data);
+        }
+    }
+}
+
+module.exports = new PositionsRepo();
diff --git a/skills/kuns9/trading-upbit-skill/scripts/strategies/strategies.js b/skills/kuns9/trading-upbit-skill/scripts/strategies/strategies.js
new file mode 100644
index 0000000000..807435e9aa
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/strategies/strategies.js
@@ -0,0 +1,23 @@
+/**
+ * 매매 전략 모듈
+ */
+
+/**
+ * 변동성 돌파 전략 (Volatility Breakout Strategy)
+ * @param {Object} currentCandle - 현재가 포함된 캔들 { open, high, low, close }
+ * @param {number} prevRange - 전일 고가 - 전일 저가
+ * @param {number} k - 변동성 계수 (기본 0.5)
+ */
+function volatilityBreakout(currentCandle, prevRange, k = 0.5) {
+    const targetPrice = currentCandle.open + (prevRange * k);
+    return {
+        targetPrice,
+        signal: currentCandle.close > targetPrice ? 'BUY' : 'HOLD',
+        isBreakout: currentCandle.high > targetPrice,
+        meta: { prevRange, k }
+    };
+}
+
+module.exports = {
+    volatilityBreakout
+};
diff --git a/skills/kuns9/trading-upbit-skill/scripts/workers/eventWorker.js b/skills/kuns9/trading-upbit-skill/scripts/workers/eventWorker.js
new file mode 100644
index 0000000000..e76334561d
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/workers/eventWorker.js
@@ -0,0 +1,57 @@
+/**
+ * 이벤트 워커 (eventWorker.js)
+ * - events.json 감시 및 처리
+ * - TradeExecutor 호출
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { UpbitClient, Logger } = require('../execution/upbitClient');
+const OrderService = require('../execution/orderService');
+const TradeExecutor = require('../execution/tradeExecutor');
+require('dotenv').config({ path: path.join(process.cwd(), '.env') });
+
+const ACCESS_KEY = process.env.UPBIT_OPEN_API_ACCESS_KEY;
+const SECRET_KEY = process.env.UPBIT_OPEN_API_SECRET_KEY;
+const EVENTS_FILE = path.join(process.cwd(), 'resources', 'events.json');
+
+const client = new UpbitClient(ACCESS_KEY, SECRET_KEY);
+const orderService = new OrderService(client);
+const executor = new TradeExecutor(orderService);
+
+async function processEvents() {
+    try {
+        const data = await fs.readFile(EVENTS_FILE, 'utf8').catch(() => '[]');
+        let events = JSON.parse(data);
+        const pendingEvents = events.filter(e => !e.processed);
+
+        if (pendingEvents.length === 0) return;
+
+        for (const event of pendingEvents) {
+            try {
+                const success = await executor.execute(event);
+                if (success) {
+                    event.processed = true;
+                    event.processedAt = new Date().toISOString();
+                } else {
+                    // 리스크 등에 의해 거부된 경우도 처리 완료로 표시 (중복 실행 방지)
+                    event.processed = true;
+                }
+            } catch (err) {
+                Logger.error(`Event Process Error (${event.id}): ${err.message}`);
+            }
+        }
+
+        await fs.writeFile(EVENTS_FILE, JSON.stringify(events, null, 2));
+    } catch (err) {
+        Logger.error(`Worker Loop Error: ${err.message}`);
+    }
+}
+
+function run() {
+    processEvents();
+    setTimeout(run, 5000); // 5초마다 체크
+}
+
+Logger.info('⚙️ Event Worker Started');
+run();
diff --git a/skills/kuns9/trading-upbit-skill/scripts/workers/monitor.js b/skills/kuns9/trading-upbit-skill/scripts/workers/monitor.js
new file mode 100644
index 0000000000..d8d81b1792
--- /dev/null
+++ b/skills/kuns9/trading-upbit-skill/scripts/workers/monitor.js
@@ -0,0 +1,132 @@
+/**
+ * 새 아키텍처 기반 모니터 (monitor.js)
+ * - 포지션 실시간 감시 (State-Aware)
+ * - 주기적 시장 스캔
+ */
+
+const { UpbitClient, Logger } = require('../execution/upbitClient');
+const marketData = require('../data/marketData');
+const positionsRepo = require('../state/positionsRepo');
+const strategies = require('../strategies/strategies');
+const fs = require('fs').promises;
+const path = require('path');
+require('dotenv').config({ path: path.join(process.cwd(), '.env') });
+
+const ACCESS_KEY = process.env.UPBIT_OPEN_API_ACCESS_KEY;
+const SECRET_KEY = process.env.UPBIT_OPEN_API_SECRET_KEY;
+const EVENTS_FILE = path.join(process.cwd(), 'resources', 'events.json');
+
+const CONFIG = {
+    priceCheckInterval: parseInt(process.env.PRICE_CHECK_INTERVAL) || 10000,
+    scanInterval: 60000 * 5,
+    watchlist: ['KRW-BTC', 'KRW-ETH', 'KRW-SOL'],
+    targetProfit: parseFloat(process.env.TARGET_PROFIT) || 0.05,
+    stopLoss: parseFloat(process.env.STOP_LOSS) || -0.05,
+};
+
+const client = new UpbitClient(ACCESS_KEY, SECRET_KEY);
+let lastScanTime = 0;
+
+async function addEvent(event) {
+    try {
+        const data = await fs.readFile(EVENTS_FILE, 'utf8').catch(() => '[]');
+        const events = JSON.parse(data);
+        const dedupeKey = `${event.type}:${event.market}`;
+
+        // 1시간 내 동일 마켓 동일 타입 이벤트 중복 방지
+        const hourAgo = Date.now() - 3600000;
+        if (events.some(e => e.dedupeKey === dedupeKey && new Date(e.createdAt).getTime() > hourAgo && !e.processed)) {
+            return;
+        }
+
+        events.push({
+            id: `evt_${Date.now()}`,
+            ...event,
+            dedupeKey,
+            processed: false,
+            createdAt: new Date().toISOString()
+        });
+        await fs.writeFile(EVENTS_FILE, JSON.stringify(events, null, 2));
+        Logger.warn(`📢 이벤트 등록: ${event.type} - ${event.market}`);
+    } catch (err) {
+        Logger.error(`Event Save Error: ${err.message}`);
+    }
+}
+
+async function scanMarkets() {
+    Logger.info('🔍 시장 스캔 시작...');
+    try {
+        const markets = await marketData.getMarkets(true);
+        for (const m of markets) {
+            // 전략 체크 로직 (Day + 60m 확인)
+            // (기존 monitor.js 로직 재활용)
+            const dayCandles = await marketData.getCandles('days', m.market, 2);
+            if (dayCandles.length < 2) continue;
+
+            const current = { high: dayCandles[0].high_price, close: dayCandles[0].trade_price };
+            const range = dayCandles[1].high_price - dayCandles[1].low_price;
+
+            const result = strategies.volatilityBreakout(current, range, 0.5);
+            if (result.signal === 'BUY') {
+                const sub = await marketData.getCandles('minutes', m.market, 1, 60);
+                if (sub[0].trade_price > sub[0].opening_price) {
+                    await addEvent({
+                        type: 'BUY_SIGNAL',
+                        market: m.market,
+                        payload: { price: current.close },
+                        meta: { strategy: 'VolatilityBreakout' }
+                    });
+                }
+            }
+        }
+        Logger.info('시장 스캔 완료');
+    } catch (err) {
+        Logger.error(`Scan Error: ${err.message}`);
+    }
+}
+
+async function monitor() {
+    try {
+        const data = await positionsRepo.load();
+        const positions = (data.positions || []).filter(p => p.state === 'OPEN');
+
+        // 시세 실시간 출력
+        const combined = [...new Set([...positions.map(p => p.market), ...CONFIG.watchlist])];
+        if (combined.length > 0) {
+            const tickers = await marketData.getTickers(combined);
+            const价格Map = {};
+            tickers.forEach(t => 价格Map[t.market] = t.trade_price);
+
+            Logger.info(`👀 [Watch] ${CONFIG.watchlist.map(m => `${m.split('-')[1]}: ${价格Map[m]?.toLocaleString()}`).join(' | ')}`);
+
+            for (const pos of positions) {
+                const current = 价格Map[pos.market];
+                if (!current) continue;
+                const entry = pos.entry.avgFillPrice;
+                const pnl = (current - entry) / entry;
+                Logger.info(`💰 [Hold] ${pos.market}: ${current.toLocaleString()}원 (${(pnl * 100).toFixed(2)}%)`);
+
+                if (pnl >= CONFIG.targetProfit) {
+                    await addEvent({ type: 'TARGET_HIT', market: pos.market });
+                } else if (pnl <= CONFIG.stopLoss) {
+                    await addEvent({ type: 'STOPLOSS_HIT', market: pos.market });
+                }
+            }
+        }
+
+        if (Date.now() - lastScanTime > CONFIG.scanInterval) {
+            await scanMarkets();
+            lastScanTime = Date.now();
+        }
+    } catch (err) {
+        Logger.error(`Monitor Error: ${err.message}`);
+    }
+}
+
+function run() {
+    monitor();
+    setTimeout(run, CONFIG.priceCheckInterval);
+}
+
+Logger.info('🚀 Monitor Engine Started');
+run();