fix: Telegram 409 감지 시 백오프 대신 polling 즉시 종료 (#180 )

409 충돌 감지 시 30초 백오프 후 재시도하는 방식에서 _running = False로 polling을 즉시 중단하는 방식으로 변경. 다중 인스턴스가 실행 중인 경우 재시도는 의미 없고 충돌만 반복됨. 이제 409 발생 시 이 프로세스의 Telegram 명령어 polling을 완전히 비활성화. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
fix: Telegram 409 충돌 시 WARNING 로그 + 30초 백오프 적용 (#180 )
2026-02-20 09:35:33 +09:00 · 2026-02-20 09:31:04 +09:00 · 2026-02-20 08:38:52 +09:00 · 2026-02-20 08:37:59 +09:00 · 2026-02-20 08:36:07 +09:00 · 2026-02-20 08:35:16 +09:00
16 changed files with 2680 additions and 88 deletions
--- a/src/broker/kis_api.py
+++ b/src/broker/kis_api.py
@@ -20,6 +20,39 @@ _KIS_VTS_HOST = "openapivts.koreainvestment.com"
 logger = logging.getLogger(__name__)


+def kr_tick_unit(price: float) -> int:
+    """Return KRX tick size for the given price level.
+
+    KRX price tick rules (domestic stocks):
+        price < 2,000        →   1원
+        2,000  ≤ price < 5,000     →   5원
+        5,000  ≤ price < 20,000    →  10원
+        20,000 ≤ price < 50,000    →  50원
+        50,000 ≤ price < 200,000   → 100원
+        200,000 ≤ price < 500,000  → 500원
+        500,000 ≤ price            → 1,000원
+    """
+    if price < 2_000:
+        return 1
+    if price < 5_000:
+        return 5
+    if price < 20_000:
+        return 10
+    if price < 50_000:
+        return 50
+    if price < 200_000:
+        return 100
+    if price < 500_000:
+        return 500
+    return 1_000
+
+
+def kr_round_down(price: float) -> int:
+    """Round *down* price to the nearest KRX tick unit."""
+    tick = kr_tick_unit(price)
+    return int(price // tick * tick)
+
+
 class LeakyBucket:
    """Simple leaky-bucket rate limiter for async code."""

@@ -198,6 +231,55 @@ class KISBroker:
        except (TimeoutError, aiohttp.ClientError) as exc:
            raise ConnectionError(f"Network error fetching orderbook: {exc}") from exc

+    async def get_current_price(
+        self, stock_code: str
+    ) -> tuple[float, float, float]:
+        """Fetch current price data for a domestic stock.
+
+        Uses the ``inquire-price`` API (FHKST01010100), which works in both
+        real and VTS environments and returns the actual last-traded price.
+
+        Returns:
+            (current_price, prdy_ctrt, frgn_ntby_qty)
+            - current_price: Last traded price in KRW.
+            - prdy_ctrt: Day change rate (%).
+            - frgn_ntby_qty: Foreigner net buy quantity.
+        """
+        await self._rate_limiter.acquire()
+        session = self._get_session()
+
+        headers = await self._auth_headers("FHKST01010100")
+        params = {
+            "FID_COND_MRKT_DIV_CODE": "J",
+            "FID_INPUT_ISCD": stock_code,
+        }
+        url = f"{self._base_url}/uapi/domestic-stock/v1/quotations/inquire-price"
+
+        def _f(val: str | None) -> float:
+            try:
+                return float(val or "0")
+            except ValueError:
+                return 0.0
+
+        try:
+            async with session.get(url, headers=headers, params=params) as resp:
+                if resp.status != 200:
+                    text = await resp.text()
+                    raise ConnectionError(
+                        f"get_current_price failed ({resp.status}): {text}"
+                    )
+                data = await resp.json()
+                out = data.get("output", {})
+                return (
+                    _f(out.get("stck_prpr")),
+                    _f(out.get("prdy_ctrt")),
+                    _f(out.get("frgn_ntby_qty")),
+                )
+        except (TimeoutError, aiohttp.ClientError) as exc:
+            raise ConnectionError(
+                f"Network error fetching current price: {exc}"
+            ) from exc
+
    async def get_balance(self) -> dict[str, Any]:
        """Fetch current account balance and holdings."""
        await self._rate_limiter.acquire()
@@ -249,13 +331,23 @@ class KISBroker:
        session = self._get_session()

        tr_id = "VTTC0802U" if order_type == "BUY" else "VTTC0801U"
+
+        # KRX requires limit orders to be rounded down to the tick unit.
+        # ORD_DVSN: "00"=지정가, "01"=시장가
+        if price > 0:
+            ord_dvsn = "00"  # 지정가
+            ord_price = kr_round_down(price)
+        else:
+            ord_dvsn = "01"  # 시장가
+            ord_price = 0
+
        body = {
            "CANO": self._account_no,
            "ACNT_PRDT_CD": self._product_cd,
            "PDNO": stock_code,
-            "ORD_DVSN": "01" if price > 0 else "06",  # 01=지정가, 06=시장가
+            "ORD_DVSN": ord_dvsn,
            "ORD_QTY": str(quantity),
-            "ORD_UNPR": str(price),
+            "ORD_UNPR": str(ord_price),
        }

        hash_key = await self._get_hash_key(body)
--- a/src/config.py
+++ b/src/config.py
@@ -93,6 +93,16 @@ class Settings(BaseSettings):
    TELEGRAM_COMMANDS_ENABLED: bool = True
    TELEGRAM_POLLING_INTERVAL: float = 1.0  # seconds

+    # Telegram notification type filters (granular control)
+    # circuit_breaker is always sent regardless — safety-critical
+    TELEGRAM_NOTIFY_TRADES: bool = True           # BUY/SELL execution alerts
+    TELEGRAM_NOTIFY_MARKET_OPEN_CLOSE: bool = True  # Market open/close alerts
+    TELEGRAM_NOTIFY_FAT_FINGER: bool = True       # Fat-finger rejection alerts
+    TELEGRAM_NOTIFY_SYSTEM_EVENTS: bool = True    # System start/shutdown alerts
+    TELEGRAM_NOTIFY_PLAYBOOK: bool = True         # Playbook generated/failed alerts
+    TELEGRAM_NOTIFY_SCENARIO_MATCH: bool = True   # Scenario matched alerts (most frequent)
+    TELEGRAM_NOTIFY_ERRORS: bool = True           # Error alerts
+
    # Overseas ranking API (KIS endpoint/TR_ID may vary by account/product)
    # Override these from .env if your account uses different specs.
    OVERSEAS_RANKING_ENABLED: bool = True
--- a/src/dashboard/app.py
+++ b/src/dashboard/app.py
@@ -259,6 +259,50 @@ def create_dashboard_app(db_path: str) -> FastAPI:
                )
            return {"market": market, "count": len(decisions), "decisions": decisions}

+    @app.get("/api/pnl/history")
+    def get_pnl_history(
+        days: int = Query(default=30, ge=1, le=365),
+        market: str = Query("all"),
+    ) -> dict[str, Any]:
+        """Return daily P&L history for charting."""
+        with _connect(db_path) as conn:
+            if market == "all":
+                rows = conn.execute(
+                    """
+                    SELECT DATE(timestamp) AS date,
+                           SUM(pnl) AS daily_pnl,
+                           COUNT(*) AS trade_count
+                    FROM trades
+                    WHERE pnl IS NOT NULL
+                      AND DATE(timestamp) >= DATE('now', ?)
+                    GROUP BY DATE(timestamp)
+                    ORDER BY DATE(timestamp)
+                    """,
+                    (f"-{days} days",),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    """
+                    SELECT DATE(timestamp) AS date,
+                           SUM(pnl) AS daily_pnl,
+                           COUNT(*) AS trade_count
+                    FROM trades
+                    WHERE pnl IS NOT NULL
+                      AND market = ?
+                      AND DATE(timestamp) >= DATE('now', ?)
+                    GROUP BY DATE(timestamp)
+                    ORDER BY DATE(timestamp)
+                    """,
+                    (market, f"-{days} days"),
+                ).fetchall()
+            return {
+                "days": days,
+                "market": market,
+                "labels": [row["date"] for row in rows],
+                "pnl": [round(float(row["daily_pnl"]), 2) for row in rows],
+                "trades": [int(row["trade_count"]) for row in rows],
+            }
+
    @app.get("/api/scenarios/active")
    def get_active_scenarios(
        market: str = Query("US"),
--- a/src/dashboard/static/index.html
+++ b/src/dashboard/static/index.html
@@ -1,9 +1,10 @@
 <!doctype html>
-<html lang="en">
+<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>The Ouroboros Dashboard</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
    <style>
      :root {
        --bg: #0b1724;
@@ -11,51 +12,390 @@
        --fg: #e6eef7;
        --muted: #9fb3c8;
        --accent: #3cb371;
+        --red: #e05555;
+        --border: #28455f;
      }
+      * { box-sizing: border-box; margin: 0; padding: 0; }
      body {
-        margin: 0;
        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
        background: radial-gradient(circle at top left, #173b58, var(--bg));
        color: var(--fg);
+        min-height: 100vh;
+        font-size: 13px;
      }
-      .wrap {
-        max-width: 900px;
-        margin: 48px auto;
-        padding: 0 16px;
+      .wrap { max-width: 1100px; margin: 0 auto; padding: 20px 16px; }
+
+      /* Header */
+      header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        margin-bottom: 20px;
+        padding-bottom: 12px;
+        border-bottom: 1px solid var(--border);
      }
+      header h1 { font-size: 18px; color: var(--accent); letter-spacing: 0.5px; }
+      .header-right { display: flex; align-items: center; gap: 12px; color: var(--muted); font-size: 12px; }
+      .refresh-btn {
+        background: none; border: 1px solid var(--border); color: var(--muted);
+        padding: 4px 10px; border-radius: 6px; cursor: pointer; font-family: inherit;
+        font-size: 12px; transition: border-color 0.2s;
+      }
+      .refresh-btn:hover { border-color: var(--accent); color: var(--accent); }
+
+      /* Summary cards */
+      .cards { display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; margin-bottom: 20px; }
+      @media (max-width: 700px) { .cards { grid-template-columns: repeat(2, 1fr); } }
      .card {
-        background: color-mix(in oklab, var(--panel), black 12%);
-        border: 1px solid #28455f;
-        border-radius: 12px;
-        padding: 20px;
+        background: var(--panel);
+        border: 1px solid var(--border);
+        border-radius: 10px;
+        padding: 16px;
      }
-      h1 {
-        margin-top: 0;
+      .card-label { color: var(--muted); font-size: 11px; margin-bottom: 6px; text-transform: uppercase; letter-spacing: 0.5px; }
+      .card-value { font-size: 22px; font-weight: 700; }
+      .card-sub { color: var(--muted); font-size: 11px; margin-top: 4px; }
+      .positive { color: var(--accent); }
+      .negative { color: var(--red); }
+      .neutral { color: var(--fg); }
+
+      /* Chart panel */
+      .chart-panel {
+        background: var(--panel);
+        border: 1px solid var(--border);
+        border-radius: 10px;
+        padding: 16px;
+        margin-bottom: 20px;
      }
-      code {
-        color: var(--accent);
+      .panel-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        margin-bottom: 16px;
      }
-      li {
-        margin: 6px 0;
-        color: var(--muted);
+      .panel-title { font-size: 13px; color: var(--muted); font-weight: 600; }
+      .chart-container { position: relative; height: 180px; }
+      .chart-error { color: var(--muted); text-align: center; padding: 40px 0; font-size: 12px; }
+
+      /* Days selector */
+      .days-selector { display: flex; gap: 4px; }
+      .day-btn {
+        background: none; border: 1px solid var(--border); color: var(--muted);
+        padding: 3px 8px; border-radius: 4px; cursor: pointer; font-family: inherit; font-size: 11px;
      }
+      .day-btn.active { border-color: var(--accent); color: var(--accent); background: rgba(60, 179, 113, 0.08); }
+
+      /* Decisions panel */
+      .decisions-panel {
+        background: var(--panel);
+        border: 1px solid var(--border);
+        border-radius: 10px;
+        padding: 16px;
+      }
+      .market-tabs { display: flex; gap: 6px; flex-wrap: wrap; }
+      .tab-btn {
+        background: none; border: 1px solid var(--border); color: var(--muted);
+        padding: 4px 10px; border-radius: 6px; cursor: pointer; font-family: inherit; font-size: 11px;
+      }
+      .tab-btn.active { border-color: var(--accent); color: var(--accent); background: rgba(60, 179, 113, 0.08); }
+      .decisions-table { width: 100%; border-collapse: collapse; margin-top: 14px; }
+      .decisions-table th {
+        text-align: left; color: var(--muted); font-size: 11px; font-weight: 600;
+        padding: 6px 8px; border-bottom: 1px solid var(--border); white-space: nowrap;
+      }
+      .decisions-table td {
+        padding: 8px 8px; border-bottom: 1px solid rgba(40, 69, 95, 0.5);
+        vertical-align: middle; white-space: nowrap;
+      }
+      .decisions-table tr:last-child td { border-bottom: none; }
+      .decisions-table tr:hover td { background: rgba(255,255,255,0.02); }
+      .badge {
+        display: inline-block; padding: 2px 7px; border-radius: 4px;
+        font-size: 11px; font-weight: 700; letter-spacing: 0.5px;
+      }
+      .badge-buy { background: rgba(60, 179, 113, 0.15); color: var(--accent); }
+      .badge-sell { background: rgba(224, 85, 85, 0.15); color: var(--red); }
+      .badge-hold { background: rgba(159, 179, 200, 0.12); color: var(--muted); }
+      .conf-bar-wrap { display: flex; align-items: center; gap: 6px; min-width: 90px; }
+      .conf-bar { flex: 1; height: 6px; background: rgba(255,255,255,0.08); border-radius: 3px; overflow: hidden; }
+      .conf-fill { height: 100%; border-radius: 3px; background: var(--accent); transition: width 0.3s; }
+      .conf-val { color: var(--muted); font-size: 11px; min-width: 26px; text-align: right; }
+      .rationale-cell { max-width: 200px; overflow: hidden; text-overflow: ellipsis; color: var(--muted); }
+      .empty-row td { text-align: center; color: var(--muted); padding: 24px; }
+
+      /* Spinner */
+      .spinner { display: inline-block; width: 12px; height: 12px; border: 2px solid var(--border); border-top-color: var(--accent); border-radius: 50%; animation: spin 0.8s linear infinite; }
+      @keyframes spin { to { transform: rotate(360deg); } }
    </style>
  </head>
  <body>
    <div class="wrap">
-      <div class="card">
-        <h1>The Ouroboros Dashboard API</h1>
-        <p>Use the following endpoints:</p>
-        <ul>
-          <li><code>/api/status</code></li>
-          <li><code>/api/playbook/{date}?market=KR</code></li>
-          <li><code>/api/scorecard/{date}?market=KR</code></li>
-          <li><code>/api/performance?market=all</code></li>
-          <li><code>/api/context/{layer}</code></li>
-          <li><code>/api/decisions?market=KR</code></li>
-          <li><code>/api/scenarios/active?market=US</code></li>
-        </ul>
+      <!-- Header -->
+      <header>
+        <h1>&#x1F40D; The Ouroboros</h1>
+        <div class="header-right">
+          <span id="last-updated">--</span>
+          <button class="refresh-btn" onclick="refreshAll()">&#x21BA; 새로고침</button>
+        </div>
+      </header>
+
+      <!-- Summary cards -->
+      <div class="cards">
+        <div class="card">
+          <div class="card-label">오늘 거래</div>
+          <div class="card-value neutral" id="card-trades">--</div>
+          <div class="card-sub" id="card-trades-sub">거래 건수</div>
+        </div>
+        <div class="card">
+          <div class="card-label">오늘 P&amp;L</div>
+          <div class="card-value" id="card-pnl">--</div>
+          <div class="card-sub" id="card-pnl-sub">실현 손익</div>
+        </div>
+        <div class="card">
+          <div class="card-label">승률</div>
+          <div class="card-value neutral" id="card-winrate">--</div>
+          <div class="card-sub">전체 누적</div>
+        </div>
+        <div class="card">
+          <div class="card-label">누적 거래</div>
+          <div class="card-value neutral" id="card-total">--</div>
+          <div class="card-sub">전체 기간</div>
+        </div>
+      </div>
+
+      <!-- P&L Chart -->
+      <div class="chart-panel">
+        <div class="panel-header">
+          <span class="panel-title">P&amp;L 추이</span>
+          <div class="days-selector">
+            <button class="day-btn active" data-days="7" onclick="selectDays(this)">7일</button>
+            <button class="day-btn" data-days="30" onclick="selectDays(this)">30일</button>
+            <button class="day-btn" data-days="90" onclick="selectDays(this)">90일</button>
+          </div>
+        </div>
+        <div class="chart-container">
+          <canvas id="pnl-chart"></canvas>
+          <div class="chart-error" id="chart-error" style="display:none">데이터 없음</div>
+        </div>
+      </div>
+
+      <!-- Decisions log -->
+      <div class="decisions-panel">
+        <div class="panel-header">
+          <span class="panel-title">최근 결정 로그</span>
+          <div class="market-tabs" id="market-tabs">
+            <button class="tab-btn active" data-market="KR" onclick="selectMarket(this)">KR</button>
+            <button class="tab-btn" data-market="US_NASDAQ" onclick="selectMarket(this)">US_NASDAQ</button>
+            <button class="tab-btn" data-market="US_NYSE" onclick="selectMarket(this)">US_NYSE</button>
+            <button class="tab-btn" data-market="JP" onclick="selectMarket(this)">JP</button>
+            <button class="tab-btn" data-market="HK" onclick="selectMarket(this)">HK</button>
+          </div>
+        </div>
+        <table class="decisions-table">
+          <thead>
+            <tr>
+              <th>시각</th>
+              <th>종목</th>
+              <th>액션</th>
+              <th>신뢰도</th>
+              <th>사유</th>
+            </tr>
+          </thead>
+          <tbody id="decisions-body">
+            <tr class="empty-row"><td colspan="5"><span class="spinner"></span></td></tr>
+          </tbody>
+        </table>
      </div>
    </div>
+
+    <script>
+      let pnlChart = null;
+      let currentDays = 7;
+      let currentMarket = 'KR';
+
+      function fmt(dt) {
+        try {
+          const d = new Date(dt);
+          return d.toLocaleTimeString('ko-KR', { hour: '2-digit', minute: '2-digit', hour12: false });
+        } catch { return dt || '--'; }
+      }
+
+      function fmtPnl(v) {
+        if (v === null || v === undefined) return '--';
+        const n = parseFloat(v);
+        const cls = n > 0 ? 'positive' : n < 0 ? 'negative' : 'neutral';
+        const sign = n > 0 ? '+' : '';
+        return `<span class="${cls}">${sign}${n.toFixed(2)}</span>`;
+      }
+
+      function badge(action) {
+        const a = (action || '').toUpperCase();
+        const cls = a === 'BUY' ? 'badge-buy' : a === 'SELL' ? 'badge-sell' : 'badge-hold';
+        return `<span class="badge ${cls}">${a}</span>`;
+      }
+
+      function confBar(conf) {
+        const pct = Math.min(Math.max(conf || 0, 0), 100);
+        return `<div class="conf-bar-wrap">
+          <div class="conf-bar"><div class="conf-fill" style="width:${pct}%"></div></div>
+          <span class="conf-val">${pct}</span>
+        </div>`;
+      }
+
+      async function fetchStatus() {
+        try {
+          const r = await fetch('/api/status');
+          if (!r.ok) return;
+          const d = await r.json();
+          const t = d.totals || {};
+          document.getElementById('card-trades').textContent = t.trade_count ?? '--';
+          const pnlEl = document.getElementById('card-pnl');
+          const pnlV = t.total_pnl;
+          if (pnlV !== undefined) {
+            const n = parseFloat(pnlV);
+            const sign = n > 0 ? '+' : '';
+            pnlEl.textContent = `${sign}${n.toFixed(2)}`;
+            pnlEl.className = `card-value ${n > 0 ? 'positive' : n < 0 ? 'negative' : 'neutral'}`;
+          }
+          document.getElementById('card-pnl-sub').textContent = `결정 ${t.decision_count ?? 0}건`;
+        } catch {}
+      }
+
+      async function fetchPerformance() {
+        try {
+          const r = await fetch('/api/performance?market=all');
+          if (!r.ok) return;
+          const d = await r.json();
+          const c = d.combined || {};
+          document.getElementById('card-winrate').textContent = c.win_rate !== undefined ? `${c.win_rate}%` : '--';
+          document.getElementById('card-total').textContent = c.total_trades ?? '--';
+        } catch {}
+      }
+
+      async function fetchPnlHistory(days) {
+        try {
+          const r = await fetch(`/api/pnl/history?days=${days}`);
+          if (!r.ok) throw new Error('fetch failed');
+          const d = await r.json();
+          renderChart(d);
+        } catch {
+          document.getElementById('chart-error').style.display = 'block';
+        }
+      }
+
+      function renderChart(data) {
+        const errEl = document.getElementById('chart-error');
+        if (!data.labels || data.labels.length === 0) {
+          errEl.style.display = 'block';
+          return;
+        }
+        errEl.style.display = 'none';
+
+        const colors = data.pnl.map(v => v >= 0 ? 'rgba(60,179,113,0.75)' : 'rgba(224,85,85,0.75)');
+        const borderColors = data.pnl.map(v => v >= 0 ? '#3cb371' : '#e05555');
+
+        if (pnlChart) { pnlChart.destroy(); pnlChart = null; }
+        const ctx = document.getElementById('pnl-chart').getContext('2d');
+        pnlChart = new Chart(ctx, {
+          type: 'bar',
+          data: {
+            labels: data.labels,
+            datasets: [{
+              label: 'Daily P&L',
+              data: data.pnl,
+              backgroundColor: colors,
+              borderColor: borderColors,
+              borderWidth: 1,
+              borderRadius: 3,
+            }]
+          },
+          options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+              legend: { display: false },
+              tooltip: {
+                callbacks: {
+                  label: ctx => {
+                    const v = ctx.parsed.y;
+                    const sign = v >= 0 ? '+' : '';
+                    const trades = data.trades[ctx.dataIndex];
+                    return [`P&L: ${sign}${v.toFixed(2)}`, `거래: ${trades}건`];
+                  }
+                }
+              }
+            },
+            scales: {
+              x: {
+                ticks: { color: '#9fb3c8', font: { size: 10 }, maxRotation: 0 },
+                grid: { color: 'rgba(40,69,95,0.4)' }
+              },
+              y: {
+                ticks: { color: '#9fb3c8', font: { size: 10 } },
+                grid: { color: 'rgba(40,69,95,0.4)' }
+              }
+            }
+          }
+        });
+      }
+
+      async function fetchDecisions(market) {
+        const tbody = document.getElementById('decisions-body');
+        tbody.innerHTML = '<tr class="empty-row"><td colspan="5"><span class="spinner"></span></td></tr>';
+        try {
+          const r = await fetch(`/api/decisions?market=${market}&limit=50`);
+          if (!r.ok) throw new Error('fetch failed');
+          const d = await r.json();
+          if (!d.decisions || d.decisions.length === 0) {
+            tbody.innerHTML = '<tr class="empty-row"><td colspan="5">결정 로그 없음</td></tr>';
+            return;
+          }
+          tbody.innerHTML = d.decisions.map(dec => `
+            <tr>
+              <td>${fmt(dec.timestamp)}</td>
+              <td>${dec.stock_code || '--'}</td>
+              <td>${badge(dec.action)}</td>
+              <td>${confBar(dec.confidence)}</td>
+              <td class="rationale-cell" title="${(dec.rationale || '').replace(/"/g, '&quot;')}">${dec.rationale || '--'}</td>
+            </tr>
+          `).join('');
+        } catch {
+          tbody.innerHTML = '<tr class="empty-row"><td colspan="5">데이터 로드 실패</td></tr>';
+        }
+      }
+
+      function selectDays(btn) {
+        document.querySelectorAll('.day-btn').forEach(b => b.classList.remove('active'));
+        btn.classList.add('active');
+        currentDays = parseInt(btn.dataset.days, 10);
+        fetchPnlHistory(currentDays);
+      }
+
+      function selectMarket(btn) {
+        document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('active'));
+        btn.classList.add('active');
+        currentMarket = btn.dataset.market;
+        fetchDecisions(currentMarket);
+      }
+
+      async function refreshAll() {
+        document.getElementById('last-updated').textContent = '업데이트 중...';
+        await Promise.all([
+          fetchStatus(),
+          fetchPerformance(),
+          fetchPnlHistory(currentDays),
+          fetchDecisions(currentMarket),
+        ]);
+        const now = new Date();
+        const timeStr = now.toLocaleTimeString('ko-KR', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });
+        document.getElementById('last-updated').textContent = `마지막 업데이트: ${timeStr}`;
+      }
+
+      // Initial load
+      refreshAll();
+
+      // Auto-refresh every 30 seconds
+      setInterval(refreshAll, 30000);
+    </script>
  </body>
 </html>
--- a/src/main.py
+++ b/src/main.py
@@ -41,8 +41,8 @@ from src.evolution.optimizer import EvolutionOptimizer
 from src.logging.decision_logger import DecisionLogger
 from src.logging_config import setup_logging
 from src.markets.schedule import MarketInfo, get_next_market_open, get_open_markets
-from src.notifications.telegram_client import TelegramClient, TelegramCommandHandler
-from src.strategy.models import DayPlaybook
+from src.notifications.telegram_client import NotificationFilter, TelegramClient, TelegramCommandHandler
+from src.strategy.models import DayPlaybook, MarketOutlook
 from src.strategy.playbook_store import PlaybookStore
 from src.strategy.pre_market_planner import PreMarketPlanner
 from src.strategy.scenario_engine import ScenarioEngine
@@ -106,6 +106,82 @@ def _extract_symbol_from_holding(item: dict[str, Any]) -> str:
    return ""


+def _extract_held_codes_from_balance(
+    balance_data: dict[str, Any],
+    *,
+    is_domestic: bool,
+) -> list[str]:
+    """Return stock codes with a positive orderable quantity from a balance response.
+
+    Uses the broker's live output1 as the source of truth so that partial fills
+    and manual external trades are always reflected correctly.
+    """
+    output1 = balance_data.get("output1", [])
+    if isinstance(output1, dict):
+        output1 = [output1]
+    if not isinstance(output1, list):
+        return []
+
+    codes: list[str] = []
+    for holding in output1:
+        if not isinstance(holding, dict):
+            continue
+        code_key = "pdno" if is_domestic else "ovrs_pdno"
+        code = str(holding.get(code_key, "")).strip().upper()
+        if not code:
+            continue
+        if is_domestic:
+            qty = int(holding.get("ord_psbl_qty") or holding.get("hldg_qty") or 0)
+        else:
+            qty = int(holding.get("ovrs_cblc_qty") or holding.get("hldg_qty") or 0)
+        if qty > 0:
+            codes.append(code)
+    return codes
+
+
+def _extract_held_qty_from_balance(
+    balance_data: dict[str, Any],
+    stock_code: str,
+    *,
+    is_domestic: bool,
+) -> int:
+    """Extract the broker-confirmed orderable quantity for a stock.
+
+    Uses the broker's live balance response (output1) as the source of truth
+    rather than the local DB, because DB records reflect order quantity which
+    may differ from actual fill quantity due to partial fills.
+
+    Domestic fields (VTTC8434R output1):
+        pdno          — 종목코드
+        ord_psbl_qty  — 주문가능수량 (preferred: excludes unsettled)
+        hldg_qty      — 보유수량 (fallback)
+
+    Overseas fields (output1):
+        ovrs_pdno     — 종목코드
+        ovrs_cblc_qty — 해외잔고수량 (preferred)
+        hldg_qty      — 보유수량 (fallback)
+    """
+    output1 = balance_data.get("output1", [])
+    if isinstance(output1, dict):
+        output1 = [output1]
+    if not isinstance(output1, list):
+        return 0
+
+    for holding in output1:
+        if not isinstance(holding, dict):
+            continue
+        code_key = "pdno" if is_domestic else "ovrs_pdno"
+        held_code = str(holding.get(code_key, "")).strip().upper()
+        if held_code != stock_code.strip().upper():
+            continue
+        if is_domestic:
+            qty = int(holding.get("ord_psbl_qty") or holding.get("hldg_qty") or 0)
+        else:
+            qty = int(holding.get("ovrs_cblc_qty") or holding.get("hldg_qty") or 0)
+        return qty
+    return 0
+
+
 def _determine_order_quantity(
    *,
    action: str,
@@ -113,16 +189,40 @@ def _determine_order_quantity(
    total_cash: float,
    candidate: ScanCandidate | None,
    settings: Settings | None,
+    broker_held_qty: int = 0,
+    playbook_allocation_pct: float | None = None,
+    scenario_confidence: int = 80,
 ) -> int:
-    """Determine order quantity using volatility-aware position sizing."""
-    if action != "BUY":
-        return 1
+    """Determine order quantity using volatility-aware position sizing.
+
+    Priority:
+    1. playbook_allocation_pct (AI-specified) scaled by scenario_confidence
+    2. Fallback: volatility-score-based allocation from scanner candidate
+    """
+    if action == "SELL":
+        return broker_held_qty
    if current_price <= 0 or total_cash <= 0:
        return 0

    if settings is None or not settings.POSITION_SIZING_ENABLED:
        return 1

+    # Use AI-specified allocation_pct if available
+    if playbook_allocation_pct is not None:
+        # Confidence scaling: confidence 80 → 1.0x, confidence 95 → 1.19x
+        confidence_scale = scenario_confidence / 80.0
+        effective_pct = min(
+            settings.POSITION_MAX_ALLOCATION_PCT,
+            max(
+                settings.POSITION_MIN_ALLOCATION_PCT,
+                playbook_allocation_pct * confidence_scale,
+            ),
+        )
+        budget = total_cash * (effective_pct / 100.0)
+        quantity = int(budget // current_price)
+        return max(0, quantity)
+
+    # Fallback: volatility-score-based allocation
    target_score = max(1.0, settings.POSITION_VOLATILITY_TARGET_SCORE)
    observed_score = candidate.score if candidate else target_score
    observed_score = max(1.0, min(100.0, observed_score))
@@ -204,7 +304,9 @@ async def trading_cycle(

    # 1. Fetch market data
    if market.is_domestic:
-        orderbook = await broker.get_orderbook(stock_code)
+        current_price, price_change_pct, foreigner_net = await broker.get_current_price(
+            stock_code
+        )
        balance_data = await broker.get_balance()

        output2 = balance_data.get("output2", [{}])
@@ -215,10 +317,6 @@ async def trading_cycle(
            else "0"
        )
        purchase_total = safe_float(output2[0].get("pchs_amt_smtl_amt", "0")) if output2 else 0
-
-        current_price = safe_float(orderbook.get("output1", {}).get("stck_prpr", "0"))
-        foreigner_net = safe_float(orderbook.get("output1", {}).get("frgn_ntby_qty", "0"))
-        price_change_pct = safe_float(orderbook.get("output1", {}).get("prdy_ctrt", "0"))
    else:
        # Overseas market
        price_data = await overseas_broker.get_overseas_price(
@@ -382,6 +480,34 @@ async def trading_cycle(
    )
    stock_playbook = playbook.get_stock_playbook(stock_code)

+    # 2.1. Apply market_outlook-based BUY confidence threshold
+    if decision.action == "BUY":
+        base_threshold = (settings.CONFIDENCE_THRESHOLD if settings else 80)
+        outlook = playbook.market_outlook
+        if outlook == MarketOutlook.BEARISH:
+            min_confidence = 90
+        elif outlook == MarketOutlook.BULLISH:
+            min_confidence = 75
+        else:
+            min_confidence = base_threshold
+        if match.confidence < min_confidence:
+            logger.info(
+                "BUY suppressed for %s (%s): confidence %d < %d (market_outlook=%s)",
+                stock_code,
+                market.name,
+                match.confidence,
+                min_confidence,
+                outlook.value,
+            )
+            decision = TradeDecision(
+                action="HOLD",
+                confidence=match.confidence,
+                rationale=(
+                    f"BUY confidence {match.confidence} < {min_confidence} "
+                    f"(market_outlook={outlook.value})"
+                ),
+            )
+
    if decision.action == "HOLD":
        open_position = get_open_position(db_conn, stock_code, market.code)
        if open_position:
@@ -389,8 +515,10 @@ async def trading_cycle(
            if entry_price > 0:
                loss_pct = (current_price - entry_price) / entry_price * 100
                stop_loss_threshold = -2.0
+                take_profit_threshold = 3.0
                if stock_playbook and stock_playbook.scenarios:
                    stop_loss_threshold = stock_playbook.scenarios[0].stop_loss_pct
+                    take_profit_threshold = stock_playbook.scenarios[0].take_profit_pct

                if loss_pct <= stop_loss_threshold:
                    decision = TradeDecision(
@@ -408,6 +536,22 @@ async def trading_cycle(
                        loss_pct,
                        stop_loss_threshold,
                    )
+                elif loss_pct >= take_profit_threshold:
+                    decision = TradeDecision(
+                        action="SELL",
+                        confidence=90,
+                        rationale=(
+                            f"Take-profit triggered ({loss_pct:.2f}% >= "
+                            f"{take_profit_threshold:.2f}%)"
+                        ),
+                    )
+                    logger.info(
+                        "Take-profit override for %s (%s): %.2f%% >= %.2f%%",
+                        stock_code,
+                        market.name,
+                        loss_pct,
+                        take_profit_threshold,
+                    )
    logger.info(
        "Decision for %s (%s): %s (confidence=%d)",
        stock_code,
@@ -468,12 +612,23 @@ async def trading_cycle(
    trade_price = current_price
    trade_pnl = 0.0
    if decision.action in ("BUY", "SELL"):
+        broker_held_qty = (
+            _extract_held_qty_from_balance(
+                balance_data, stock_code, is_domestic=market.is_domestic
+            )
+            if decision.action == "SELL"
+            else 0
+        )
+        matched_scenario = match.matched_scenario
        quantity = _determine_order_quantity(
            action=decision.action,
            current_price=current_price,
            total_cash=total_cash,
            candidate=candidate,
            settings=settings,
+            broker_held_qty=broker_held_qty,
+            playbook_allocation_pct=matched_scenario.allocation_pct if matched_scenario else None,
+            scenario_confidence=match.confidence,
        )
        if quantity <= 0:
            logger.info(
@@ -726,15 +881,8 @@ async def run_daily_session(
        for stock_code in watchlist:
            try:
                if market.is_domestic:
-                    orderbook = await broker.get_orderbook(stock_code)
-                    current_price = safe_float(
-                        orderbook.get("output1", {}).get("stck_prpr", "0")
-                    )
-                    foreigner_net = safe_float(
-                        orderbook.get("output1", {}).get("frgn_ntby_qty", "0")
-                    )
-                    price_change_pct = safe_float(
-                        orderbook.get("output1", {}).get("prdy_ctrt", "0")
+                    current_price, price_change_pct, foreigner_net = (
+                        await broker.get_current_price(stock_code)
                    )
                else:
                    price_data = await overseas_broker.get_overseas_price(
@@ -900,12 +1048,20 @@ async def run_daily_session(
            trade_pnl = 0.0
            order_succeeded = True
            if decision.action in ("BUY", "SELL"):
+                daily_broker_held_qty = (
+                    _extract_held_qty_from_balance(
+                        balance_data, stock_code, is_domestic=market.is_domestic
+                    )
+                    if decision.action == "SELL"
+                    else 0
+                )
                quantity = _determine_order_quantity(
                    action=decision.action,
                    current_price=stock_data["current_price"],
                    total_cash=total_cash,
                    candidate=candidate_map.get(stock_code),
                    settings=settings,
+                    broker_held_qty=daily_broker_held_qty,
                )
                if quantity <= 0:
                    logger.info(
@@ -1217,6 +1373,15 @@ async def run(settings: Settings) -> None:
        bot_token=settings.TELEGRAM_BOT_TOKEN,
        chat_id=settings.TELEGRAM_CHAT_ID,
        enabled=settings.TELEGRAM_ENABLED,
+        notification_filter=NotificationFilter(
+            trades=settings.TELEGRAM_NOTIFY_TRADES,
+            market_open_close=settings.TELEGRAM_NOTIFY_MARKET_OPEN_CLOSE,
+            fat_finger=settings.TELEGRAM_NOTIFY_FAT_FINGER,
+            system_events=settings.TELEGRAM_NOTIFY_SYSTEM_EVENTS,
+            playbook=settings.TELEGRAM_NOTIFY_PLAYBOOK,
+            scenario_match=settings.TELEGRAM_NOTIFY_SCENARIO_MATCH,
+            errors=settings.TELEGRAM_NOTIFY_ERRORS,
+        ),
    )

    # Initialize Telegram command handler
@@ -1235,7 +1400,11 @@ async def run(settings: Settings) -> None:
            "/review - Recent scorecards\n"
            "/dashboard - Dashboard URL/status\n"
            "/stop - Pause trading\n"
-            "/resume - Resume trading"
+            "/resume - Resume trading\n"
+            "/notify - Show notification filter status\n"
+            "/notify [key] [on|off] - Toggle notification type\n"
+            "  Keys: trades, market, scenario, playbook,\n"
+            "        system, fatfinger, errors, all"
        )
        await telegram.send_message(message)

@@ -1488,6 +1657,63 @@ async def run(settings: Settings) -> None:
                "<b>⚠️ Error</b>\n\nFailed to retrieve reviews."
            )

+    async def handle_notify(args: list[str]) -> None:
+        """Handle /notify [key] [on|off] — query or change notification filters."""
+        status = telegram.filter_status()
+
+        # /notify — show current state
+        if not args:
+            lines = ["<b>🔔 알림 필터 현재 상태</b>\n"]
+            for key, enabled in status.items():
+                icon = "✅" if enabled else "❌"
+                lines.append(f"{icon} <code>{key}</code>")
+            lines.append("\n<i>예) /notify scenario off</i>")
+            lines.append("<i>예) /notify all off</i>")
+            await telegram.send_message("\n".join(lines))
+            return
+
+        # /notify [key] — missing on/off
+        if len(args) == 1:
+            key = args[0].lower()
+            if key == "all":
+                lines = ["<b>🔔 알림 필터 현재 상태</b>\n"]
+                for k, enabled in status.items():
+                    icon = "✅" if enabled else "❌"
+                    lines.append(f"{icon} <code>{k}</code>")
+                await telegram.send_message("\n".join(lines))
+            elif key in status:
+                icon = "✅" if status[key] else "❌"
+                await telegram.send_message(
+                    f"<b>🔔 {key}</b>: {icon} {'켜짐' if status[key] else '꺼짐'}\n"
+                    f"<i>/notify {key} on  또는  /notify {key} off</i>"
+                )
+            else:
+                valid = ", ".join(list(status.keys()) + ["all"])
+                await telegram.send_message(
+                    f"❌ 알 수 없는 키: <code>{key}</code>\n"
+                    f"유효한 키: {valid}"
+                )
+            return
+
+        # /notify [key] [on|off]
+        key, toggle = args[0].lower(), args[1].lower()
+        if toggle not in ("on", "off"):
+            await telegram.send_message("❌ on 또는 off 를 입력해 주세요.")
+            return
+        value = toggle == "on"
+        if telegram.set_notification(key, value):
+            icon = "✅" if value else "❌"
+            label = f"전체 알림" if key == "all" else f"<code>{key}</code> 알림"
+            state = "켜짐" if value else "꺼짐"
+            await telegram.send_message(f"{icon} {label} → {state}")
+            logger.info("Notification filter changed via Telegram: %s=%s", key, value)
+        else:
+            valid = ", ".join(list(telegram.filter_status().keys()) + ["all"])
+            await telegram.send_message(
+                f"❌ 알 수 없는 키: <code>{key}</code>\n"
+                f"유효한 키: {valid}"
+            )
+
    async def handle_dashboard() -> None:
        """Handle /dashboard command - show dashboard URL if enabled."""
        if not settings.DASHBOARD_ENABLED:
@@ -1511,6 +1737,7 @@ async def run(settings: Settings) -> None:
    command_handler.register_command("scenarios", handle_scenarios)
    command_handler.register_command("review", handle_review)
    command_handler.register_command("dashboard", handle_dashboard)
+    command_handler.register_command_with_args("notify", handle_notify)

    # Initialize volatility hunter
    volatility_analyzer = VolatilityAnalyzer(min_volume_surge=2.0, min_price_change=1.0)
@@ -1801,8 +2028,38 @@ async def run(settings: Settings) -> None:
                        except Exception as exc:
                            logger.error("Smart Scanner failed for %s: %s", market.name, exc)

-                    # Get active stocks from scanner (dynamic, no static fallback)
-                    stock_codes = active_stocks.get(market.code, [])
+                    # Get active stocks from scanner (dynamic, no static fallback).
+                    # Also include currently-held positions so stop-loss /
+                    # take-profit can fire even when a holding drops off the
+                    # scanner.  Broker balance is the source of truth here —
+                    # unlike the local DB it reflects actual fills and any
+                    # manual trades done outside the bot.
+                    scanner_codes = active_stocks.get(market.code, [])
+                    try:
+                        if market.is_domestic:
+                            held_balance = await broker.get_balance()
+                        else:
+                            held_balance = await overseas_broker.get_overseas_balance(
+                                market.exchange_code
+                            )
+                        held_codes = _extract_held_codes_from_balance(
+                            held_balance, is_domestic=market.is_domestic
+                        )
+                    except Exception as exc:
+                        logger.warning(
+                            "Failed to fetch holdings for %s: %s — skipping holdings merge",
+                            market.name, exc,
+                        )
+                        held_codes = []
+
+                    stock_codes = list(dict.fromkeys(scanner_codes + held_codes))
+                    extra_held = [c for c in held_codes if c not in set(scanner_codes)]
+                    if extra_held:
+                        logger.info(
+                            "Holdings added to loop for %s (not in scanner): %s",
+                            market.name, extra_held,
+                        )
+
                    if not stock_codes:
                        logger.debug("No active stocks for market %s", market.code)
                        continue
--- a/src/notifications/telegram_client.py
+++ b/src/notifications/telegram_client.py
@@ -4,8 +4,9 @@ import asyncio
 import logging
 import time
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, fields
 from enum import Enum
+from typing import ClassVar

 import aiohttp

@@ -58,6 +59,45 @@ class LeakyBucket:
                self._tokens -= 1.0


+@dataclass
+class NotificationFilter:
+    """Granular on/off flags for each notification type.
+
+    circuit_breaker is intentionally omitted — it is always sent regardless.
+    """
+
+    # Maps user-facing command keys to dataclass field names
+    KEYS: ClassVar[dict[str, str]] = {
+        "trades": "trades",
+        "market": "market_open_close",
+        "fatfinger": "fat_finger",
+        "system": "system_events",
+        "playbook": "playbook",
+        "scenario": "scenario_match",
+        "errors": "errors",
+    }
+
+    trades: bool = True
+    market_open_close: bool = True
+    fat_finger: bool = True
+    system_events: bool = True
+    playbook: bool = True
+    scenario_match: bool = True
+    errors: bool = True
+
+    def set_flag(self, key: str, value: bool) -> bool:
+        """Set a filter flag by user-facing key. Returns False if key is unknown."""
+        field = self.KEYS.get(key.lower())
+        if field is None:
+            return False
+        setattr(self, field, value)
+        return True
+
+    def as_dict(self) -> dict[str, bool]:
+        """Return {user_key: current_value} for display."""
+        return {k: getattr(self, field) for k, field in self.KEYS.items()}
+
+
@dataclass
 class NotificationMessage:
    """Internal notification message structure."""
@@ -79,6 +119,7 @@ class TelegramClient:
        chat_id: str | None = None,
        enabled: bool = True,
        rate_limit: float = DEFAULT_RATE,
+        notification_filter: NotificationFilter | None = None,
    ) -> None:
        """
        Initialize Telegram client.
@@ -88,12 +129,14 @@ class TelegramClient:
            chat_id: Target chat ID (user or group)
            enabled: Enable/disable notifications globally
            rate_limit: Maximum messages per second
+            notification_filter: Granular per-type on/off flags
        """
        self._bot_token = bot_token
        self._chat_id = chat_id
        self._enabled = enabled
        self._rate_limiter = LeakyBucket(rate=rate_limit)
        self._session: aiohttp.ClientSession | None = None
+        self._filter = notification_filter if notification_filter is not None else NotificationFilter()

        if not enabled:
            logger.info("Telegram notifications disabled via configuration")
@@ -118,6 +161,26 @@ class TelegramClient:
        if self._session is not None and not self._session.closed:
            await self._session.close()

+    def set_notification(self, key: str, value: bool) -> bool:
+        """Toggle a notification type by user-facing key at runtime.
+
+        Args:
+            key: User-facing key (e.g. "scenario", "market", "all")
+            value: True to enable, False to disable
+
+        Returns:
+            True if key was valid, False if unknown.
+        """
+        if key == "all":
+            for k in NotificationFilter.KEYS:
+                self._filter.set_flag(k, value)
+            return True
+        return self._filter.set_flag(key, value)
+
+    def filter_status(self) -> dict[str, bool]:
+        """Return current per-type filter state keyed by user-facing names."""
+        return self._filter.as_dict()
+
    async def send_message(self, text: str, parse_mode: str = "HTML") -> bool:
        """
        Send a generic text message to Telegram.
@@ -193,6 +256,8 @@ class TelegramClient:
            price: Execution price
            confidence: AI confidence level (0-100)
        """
+        if not self._filter.trades:
+            return
        emoji = "🟢" if action == "BUY" else "🔴"
        message = (
            f"<b>{emoji} {action}</b>\n"
@@ -212,6 +277,8 @@ class TelegramClient:
        Args:
            market_name: Name of the market (e.g., "Korea", "United States")
        """
+        if not self._filter.market_open_close:
+            return
        message = f"<b>Market Open</b>\n{market_name} trading session started"
        await self._send_notification(
            NotificationMessage(priority=NotificationPriority.LOW, message=message)
@@ -225,6 +292,8 @@ class TelegramClient:
            market_name: Name of the market
            pnl_pct: Final P&L percentage for the session
        """
+        if not self._filter.market_open_close:
+            return
        pnl_sign = "+" if pnl_pct >= 0 else ""
        pnl_emoji = "📈" if pnl_pct >= 0 else "📉"
        message = (
@@ -271,6 +340,8 @@ class TelegramClient:
            total_cash: Total available cash
            max_pct: Maximum allowed percentage
        """
+        if not self._filter.fat_finger:
+            return
        attempted_pct = (order_amount / total_cash) * 100 if total_cash > 0 else 0
        message = (
            f"<b>Fat-Finger Protection</b>\n"
@@ -293,6 +364,8 @@ class TelegramClient:
            mode: Trading mode ("paper" or "live")
            enabled_markets: List of enabled market codes
        """
+        if not self._filter.system_events:
+            return
        mode_emoji = "📝" if mode == "paper" else "💰"
        markets_str = ", ".join(enabled_markets)
        message = (
@@ -320,6 +393,8 @@ class TelegramClient:
            scenario_count: Total number of scenarios
            token_count: Gemini token usage for the playbook
        """
+        if not self._filter.playbook:
+            return
        message = (
            f"<b>Playbook Generated</b>\n"
            f"Market: {market}\n"
@@ -347,6 +422,8 @@ class TelegramClient:
            condition_summary: Short summary of the matched condition
            confidence: Scenario confidence (0-100)
        """
+        if not self._filter.scenario_match:
+            return
        message = (
            f"<b>Scenario Matched</b>\n"
            f"Symbol: <code>{stock_code}</code>\n"
@@ -366,6 +443,8 @@ class TelegramClient:
            market: Market code (e.g., "KR", "US")
            reason: Failure reason summary
        """
+        if not self._filter.playbook:
+            return
        message = (
            f"<b>Playbook Failed</b>\n"
            f"Market: {market}\n"
@@ -382,6 +461,8 @@ class TelegramClient:
        Args:
            reason: Reason for shutdown (e.g., "Normal shutdown", "Circuit breaker")
        """
+        if not self._filter.system_events:
+            return
        message = f"<b>System Shutdown</b>\n{reason}"
        priority = (
            NotificationPriority.CRITICAL
@@ -403,6 +484,8 @@ class TelegramClient:
            error_msg: Error message
            context: Error context (e.g., stock code, market)
        """
+        if not self._filter.errors:
+            return
        message = (
            f"<b>Error: {error_type}</b>\n"
            f"Context: {context}\n"
@@ -429,6 +512,7 @@ class TelegramCommandHandler:
        self._client = client
        self._polling_interval = polling_interval
        self._commands: dict[str, Callable[[], Awaitable[None]]] = {}
+        self._commands_with_args: dict[str, Callable[[list[str]], Awaitable[None]]] = {}
        self._last_update_id = 0
        self._polling_task: asyncio.Task[None] | None = None
        self._running = False
@@ -437,7 +521,7 @@ class TelegramCommandHandler:
        self, command: str, handler: Callable[[], Awaitable[None]]
    ) -> None:
        """
-        Register a command handler.
+        Register a command handler (no arguments).

        Args:
            command: Command name (without leading slash, e.g., "start")
@@ -446,6 +530,19 @@ class TelegramCommandHandler:
        self._commands[command] = handler
        logger.debug("Registered command handler: /%s", command)

+    def register_command_with_args(
+        self, command: str, handler: Callable[[list[str]], Awaitable[None]]
+    ) -> None:
+        """
+        Register a command handler that receives trailing arguments.
+
+        Args:
+            command: Command name (without leading slash, e.g., "notify")
+            handler: Async function receiving list of argument tokens
+        """
+        self._commands_with_args[command] = handler
+        logger.debug("Registered command handler (with args): /%s", command)
+
    async def start_polling(self) -> None:
        """Start long polling for commands."""
        if self._running:
@@ -507,9 +604,19 @@ class TelegramCommandHandler:
            async with session.post(url, json=payload) as resp:
                if resp.status != 200:
                    error_text = await resp.text()
-                    logger.error(
-                        "getUpdates API error (status=%d): %s", resp.status, error_text
-                    )
+                    if resp.status == 409:
+                        # Another bot instance is already polling — stop this poller entirely.
+                        # Retrying would keep conflicting with the other instance.
+                        self._running = False
+                        logger.warning(
+                            "Telegram conflict (409): another instance is already polling. "
+                            "Disabling Telegram commands for this process. "
+                            "Ensure only one instance of The Ouroboros is running at a time.",
+                        )
+                    else:
+                        logger.error(
+                            "getUpdates API error (status=%d): %s", resp.status, error_text
+                        )
                    return []

                data = await resp.json()
@@ -566,11 +673,14 @@ class TelegramCommandHandler:
            # Remove @botname suffix if present (for group chats)
            command_name = command_parts[0].split("@")[0]

-            # Execute handler
-            handler = self._commands.get(command_name)
-            if handler:
+            # Execute handler (args-aware handlers take priority)
+            args_handler = self._commands_with_args.get(command_name)
+            if args_handler:
+                logger.info("Executing command: /%s %s", command_name, command_parts[1:])
+                await args_handler(command_parts[1:])
+            elif command_name in self._commands:
                logger.info("Executing command: /%s", command_name)
-                await handler()
+                await self._commands[command_name]()
            else:
                logger.debug("Unknown command: /%s", command_name)
                await self._client.send_message(
--- a/src/strategy/models.py
+++ b/src/strategy/models.py
@@ -46,6 +46,18 @@ class StockCondition(BaseModel):

    The ScenarioEngine evaluates all non-None fields as AND conditions.
    A condition matches only if ALL specified fields are satisfied.
+
+    Technical indicator fields:
+        rsi_below / rsi_above — RSI threshold
+        volume_ratio_above / volume_ratio_below — volume vs previous day
+        price_above / price_below — absolute price level
+        price_change_pct_above / price_change_pct_below — intraday % change
+
+    Position-aware fields (require market_data enrichment from open position):
+        unrealized_pnl_pct_above — matches if unrealized P&L > threshold (e.g. 3.0 → +3%)
+        unrealized_pnl_pct_below — matches if unrealized P&L < threshold (e.g. -2.0 → -2%)
+        holding_days_above — matches if position held for more than N days
+        holding_days_below — matches if position held for fewer than N days
    """

    rsi_below: float | None = None
@@ -56,6 +68,10 @@ class StockCondition(BaseModel):
    price_below: float | None = None
    price_change_pct_above: float | None = None
    price_change_pct_below: float | None = None
+    unrealized_pnl_pct_above: float | None = None
+    unrealized_pnl_pct_below: float | None = None
+    holding_days_above: int | None = None
+    holding_days_below: int | None = None

    def has_any_condition(self) -> bool:
        """Check if at least one condition field is set."""
@@ -70,6 +86,10 @@ class StockCondition(BaseModel):
                self.price_below,
                self.price_change_pct_above,
                self.price_change_pct_below,
+                self.unrealized_pnl_pct_above,
+                self.unrealized_pnl_pct_below,
+                self.holding_days_above,
+                self.holding_days_below,
            )
        )

--- a/src/strategy/pre_market_planner.py
+++ b/src/strategy/pre_market_planner.py
@@ -75,6 +75,7 @@ class PreMarketPlanner:
        market: str,
        candidates: list[ScanCandidate],
        today: date | None = None,
+        current_holdings: list[dict] | None = None,
    ) -> DayPlaybook:
        """Generate a DayPlaybook for a market using Gemini.

@@ -82,6 +83,10 @@ class PreMarketPlanner:
            market: Market code ("KR" or "US")
            candidates: Stock candidates from SmartVolatilityScanner
            today: Override date (defaults to date.today()). Use market-local date.
+            current_holdings: Currently held positions with entry_price and unrealized_pnl_pct.
+                Each dict: {"stock_code": str, "name": str, "qty": int,
+                            "entry_price": float, "unrealized_pnl_pct": float,
+                            "holding_days": int}

        Returns:
            DayPlaybook with scenarios. Empty/defensive if no candidates or failure.
@@ -106,6 +111,7 @@ class PreMarketPlanner:
                context_data,
                self_market_scorecard,
                cross_market,
+                current_holdings=current_holdings,
            )

            # 3. Call Gemini
@@ -118,7 +124,8 @@ class PreMarketPlanner:

            # 4. Parse response
            playbook = self._parse_response(
-                decision.rationale, today, market, candidates, cross_market
+                decision.rationale, today, market, candidates, cross_market,
+                current_holdings=current_holdings,
            )
            playbook_with_tokens = playbook.model_copy(
                update={"token_count": decision.token_count}
@@ -230,6 +237,7 @@ class PreMarketPlanner:
        context_data: dict[str, Any],
        self_market_scorecard: dict[str, Any] | None,
        cross_market: CrossMarketContext | None,
+        current_holdings: list[dict] | None = None,
    ) -> str:
        """Build a structured prompt for Gemini to generate scenario JSON."""
        max_scenarios = self._settings.MAX_SCENARIOS_PER_STOCK
@@ -241,6 +249,26 @@ class PreMarketPlanner:
            for c in candidates
        )

+        holdings_text = ""
+        if current_holdings:
+            lines = []
+            for h in current_holdings:
+                code = h.get("stock_code", "")
+                name = h.get("name", "")
+                qty = h.get("qty", 0)
+                entry_price = h.get("entry_price", 0.0)
+                pnl_pct = h.get("unrealized_pnl_pct", 0.0)
+                holding_days = h.get("holding_days", 0)
+                lines.append(
+                    f"  - {code} ({name}): {qty}주 @ {entry_price:,.0f}, "
+                    f"미실현손익 {pnl_pct:+.2f}%, 보유 {holding_days}일"
+                )
+            holdings_text = (
+                "\n## Current Holdings (보유 중 — SELL/HOLD 전략 고려 필요)\n"
+                + "\n".join(lines)
+                + "\n"
+            )
+
        cross_market_text = ""
        if cross_market:
            cross_market_text = (
@@ -273,10 +301,20 @@ class PreMarketPlanner:
                    for key, value in list(layer_data.items())[:5]:
                        context_text += f"  - {key}: {value}\n"

+        holdings_instruction = ""
+        if current_holdings:
+            holding_codes = [h.get("stock_code", "") for h in current_holdings]
+            holdings_instruction = (
+                f"- Also include SELL/HOLD scenarios for held stocks: "
+                f"{', '.join(holding_codes)} "
+                f"(even if not in candidates list)\n"
+            )
+
        return (
            f"You are a pre-market trading strategist for the {market} market.\n"
            f"Generate structured trading scenarios for today.\n\n"
            f"## Candidates (from volatility scanner)\n{candidates_text}\n"
+            f"{holdings_text}"
            f"{self_market_text}"
            f"{cross_market_text}"
            f"{context_text}\n"
@@ -294,7 +332,8 @@ class PreMarketPlanner:
            f'      "stock_code": "...",\n'
            f'      "scenarios": [\n'
            f'        {{\n'
-            f'          "condition": {{"rsi_below": 30, "volume_ratio_above": 2.0}},\n'
+            f'          "condition": {{"rsi_below": 30, "volume_ratio_above": 2.0,'
+            f' "unrealized_pnl_pct_above": 3.0, "holding_days_above": 5}},\n'
            f'          "action": "BUY|SELL|HOLD",\n'
            f'          "confidence": 85,\n'
            f'          "allocation_pct": 10.0,\n'
@@ -308,7 +347,8 @@ class PreMarketPlanner:
            f'}}\n\n'
            f"Rules:\n"
            f"- Max {max_scenarios} scenarios per stock\n"
-            f"- Only use stocks from the candidates list\n"
+            f"- Candidates list is the primary source for BUY candidates\n"
+            f"{holdings_instruction}"
            f"- Confidence 0-100 (80+ for actionable trades)\n"
            f"- stop_loss_pct must be <= 0, take_profit_pct must be >= 0\n"
            f"- Return ONLY the JSON, no markdown fences or explanation\n"
@@ -321,12 +361,19 @@ class PreMarketPlanner:
        market: str,
        candidates: list[ScanCandidate],
        cross_market: CrossMarketContext | None,
+        current_holdings: list[dict] | None = None,
    ) -> DayPlaybook:
        """Parse Gemini's JSON response into a validated DayPlaybook."""
        cleaned = self._extract_json(response_text)
        data = json.loads(cleaned)

        valid_codes = {c.stock_code for c in candidates}
+        # Holdings are also valid — AI may generate SELL/HOLD scenarios for them
+        if current_holdings:
+            for h in current_holdings:
+                code = h.get("stock_code", "")
+                if code:
+                    valid_codes.add(code)

        # Parse market outlook
        outlook_str = data.get("market_outlook", "neutral")
@@ -390,6 +437,10 @@ class PreMarketPlanner:
                price_below=cond_data.get("price_below"),
                price_change_pct_above=cond_data.get("price_change_pct_above"),
                price_change_pct_below=cond_data.get("price_change_pct_below"),
+                unrealized_pnl_pct_above=cond_data.get("unrealized_pnl_pct_above"),
+                unrealized_pnl_pct_below=cond_data.get("unrealized_pnl_pct_below"),
+                holding_days_above=cond_data.get("holding_days_above"),
+                holding_days_below=cond_data.get("holding_days_below"),
            )

            if not condition.has_any_condition():
--- a/src/strategy/scenario_engine.py
+++ b/src/strategy/scenario_engine.py
@@ -206,6 +206,37 @@ class ScenarioEngine:
        if condition.price_change_pct_below is not None:
            checks.append(price_change_pct is not None and price_change_pct < condition.price_change_pct_below)

+        # Position-aware conditions
+        unrealized_pnl_pct = self._safe_float(market_data.get("unrealized_pnl_pct"))
+        if condition.unrealized_pnl_pct_above is not None or condition.unrealized_pnl_pct_below is not None:
+            if "unrealized_pnl_pct" not in market_data:
+                self._warn_missing_key("unrealized_pnl_pct")
+        if condition.unrealized_pnl_pct_above is not None:
+            checks.append(
+                unrealized_pnl_pct is not None
+                and unrealized_pnl_pct > condition.unrealized_pnl_pct_above
+            )
+        if condition.unrealized_pnl_pct_below is not None:
+            checks.append(
+                unrealized_pnl_pct is not None
+                and unrealized_pnl_pct < condition.unrealized_pnl_pct_below
+            )
+
+        holding_days = self._safe_float(market_data.get("holding_days"))
+        if condition.holding_days_above is not None or condition.holding_days_below is not None:
+            if "holding_days" not in market_data:
+                self._warn_missing_key("holding_days")
+        if condition.holding_days_above is not None:
+            checks.append(
+                holding_days is not None
+                and holding_days > condition.holding_days_above
+            )
+        if condition.holding_days_below is not None:
+            checks.append(
+                holding_days is not None
+                and holding_days < condition.holding_days_below
+            )
+
        return len(checks) > 0 and all(checks)

    def _evaluate_global_condition(
@@ -266,5 +297,9 @@ class ScenarioEngine:
            details["current_price"] = self._safe_float(market_data.get("current_price"))
        if condition.price_change_pct_above is not None or condition.price_change_pct_below is not None:
            details["price_change_pct"] = self._safe_float(market_data.get("price_change_pct"))
+        if condition.unrealized_pnl_pct_above is not None or condition.unrealized_pnl_pct_below is not None:
+            details["unrealized_pnl_pct"] = self._safe_float(market_data.get("unrealized_pnl_pct"))
+        if condition.holding_days_above is not None or condition.holding_days_below is not None:
+            details["holding_days"] = self._safe_float(market_data.get("holding_days"))

        return details
--- a/tests/test_broker.py
+++ b/tests/test_broker.py
@@ -375,3 +375,201 @@ class TestFetchMarketRankings:
        assert result[0]["stock_code"] == "005930"
        assert result[0]["price"] == 75000.0
        assert result[0]["change_rate"] == 2.5
+
+
+# ---------------------------------------------------------------------------
+# KRX tick unit / round-down helpers (issue #157)
+# ---------------------------------------------------------------------------
+
+
+from src.broker.kis_api import kr_tick_unit, kr_round_down  # noqa: E402
+
+
+class TestKrTickUnit:
+    """kr_tick_unit and kr_round_down must implement KRX price tick rules."""
+
+    @pytest.mark.parametrize(
+        "price, expected_tick",
+        [
+            (1999, 1),
+            (2000, 5),
+            (4999, 5),
+            (5000, 10),
+            (19999, 10),
+            (20000, 50),
+            (49999, 50),
+            (50000, 100),
+            (199999, 100),
+            (200000, 500),
+            (499999, 500),
+            (500000, 1000),
+            (1000000, 1000),
+        ],
+    )
+    def test_tick_unit_boundaries(self, price: int, expected_tick: int) -> None:
+        assert kr_tick_unit(price) == expected_tick
+
+    @pytest.mark.parametrize(
+        "price, expected_rounded",
+        [
+            (188150, 188100),   # 100원 단위, 50원 잔여 → 내림
+            (188100, 188100),   # 이미 정렬됨
+            (75050, 75000),     # 100원 단위, 50원 잔여 → 내림
+            (49950, 49950),     # 50원 단위 정렬됨
+            (49960, 49950),     # 50원 단위, 10원 잔여 → 내림
+            (1999, 1999),       # 1원 단위 → 그대로
+            (5003, 5000),       # 10원 단위, 3원 잔여 → 내림
+        ],
+    )
+    def test_round_down_to_tick(self, price: int, expected_rounded: int) -> None:
+        assert kr_round_down(price) == expected_rounded
+
+
+# ---------------------------------------------------------------------------
+# get_current_price (issue #157)
+# ---------------------------------------------------------------------------
+
+
+class TestGetCurrentPrice:
+    """get_current_price must use inquire-price API and return (price, change, foreigner)."""
+
+    @pytest.fixture
+    def broker(self, settings) -> KISBroker:
+        b = KISBroker(settings)
+        b._access_token = "tok"
+        b._token_expires_at = float("inf")
+        b._rate_limiter.acquire = AsyncMock()
+        return b
+
+    @pytest.mark.asyncio
+    async def test_returns_correct_fields(self, broker: KISBroker) -> None:
+        mock_resp = AsyncMock()
+        mock_resp.status = 200
+        mock_resp.json = AsyncMock(
+            return_value={
+                "rt_cd": "0",
+                "output": {
+                    "stck_prpr": "188600",
+                    "prdy_ctrt": "3.97",
+                    "frgn_ntby_qty": "12345",
+                },
+            }
+        )
+        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
+        mock_resp.__aexit__ = AsyncMock(return_value=False)
+
+        with patch("aiohttp.ClientSession.get", return_value=mock_resp) as mock_get:
+            price, change_pct, foreigner = await broker.get_current_price("005930")
+
+        assert price == 188600.0
+        assert change_pct == 3.97
+        assert foreigner == 12345.0
+
+        call_kwargs = mock_get.call_args
+        url = call_kwargs[0][0] if call_kwargs[0] else call_kwargs[1].get("url", "")
+        headers = call_kwargs[1].get("headers", {})
+        assert "inquire-price" in url
+        assert headers.get("tr_id") == "FHKST01010100"
+
+    @pytest.mark.asyncio
+    async def test_http_error_raises_connection_error(self, broker: KISBroker) -> None:
+        mock_resp = AsyncMock()
+        mock_resp.status = 500
+        mock_resp.text = AsyncMock(return_value="Internal Server Error")
+        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
+        mock_resp.__aexit__ = AsyncMock(return_value=False)
+
+        with patch("aiohttp.ClientSession.get", return_value=mock_resp):
+            with pytest.raises(ConnectionError, match="get_current_price failed"):
+                await broker.get_current_price("005930")
+
+
+# ---------------------------------------------------------------------------
+# send_order tick rounding and ORD_DVSN (issue #157)
+# ---------------------------------------------------------------------------
+
+
+class TestSendOrderTickRounding:
+    """send_order must apply KRX tick rounding and correct ORD_DVSN codes."""
+
+    @pytest.fixture
+    def broker(self, settings) -> KISBroker:
+        b = KISBroker(settings)
+        b._access_token = "tok"
+        b._token_expires_at = float("inf")
+        b._rate_limiter.acquire = AsyncMock()
+        return b
+
+    @pytest.mark.asyncio
+    async def test_limit_order_rounds_down_to_tick(self, broker: KISBroker) -> None:
+        """Price 188150 (not on 100-won tick) must be rounded to 188100."""
+        mock_hash = AsyncMock()
+        mock_hash.status = 200
+        mock_hash.json = AsyncMock(return_value={"HASH": "h"})
+        mock_hash.__aenter__ = AsyncMock(return_value=mock_hash)
+        mock_hash.__aexit__ = AsyncMock(return_value=False)
+
+        mock_order = AsyncMock()
+        mock_order.status = 200
+        mock_order.json = AsyncMock(return_value={"rt_cd": "0"})
+        mock_order.__aenter__ = AsyncMock(return_value=mock_order)
+        mock_order.__aexit__ = AsyncMock(return_value=False)
+
+        with patch(
+            "aiohttp.ClientSession.post", side_effect=[mock_hash, mock_order]
+        ) as mock_post:
+            await broker.send_order("005930", "BUY", 1, price=188150)
+
+        order_call = mock_post.call_args_list[1]
+        body = order_call[1].get("json", {})
+        assert body["ORD_UNPR"] == "188100"  # rounded down
+        assert body["ORD_DVSN"] == "00"       # 지정가
+
+    @pytest.mark.asyncio
+    async def test_limit_order_ord_dvsn_is_00(self, broker: KISBroker) -> None:
+        """send_order with price>0 must use ORD_DVSN='00' (지정가)."""
+        mock_hash = AsyncMock()
+        mock_hash.status = 200
+        mock_hash.json = AsyncMock(return_value={"HASH": "h"})
+        mock_hash.__aenter__ = AsyncMock(return_value=mock_hash)
+        mock_hash.__aexit__ = AsyncMock(return_value=False)
+
+        mock_order = AsyncMock()
+        mock_order.status = 200
+        mock_order.json = AsyncMock(return_value={"rt_cd": "0"})
+        mock_order.__aenter__ = AsyncMock(return_value=mock_order)
+        mock_order.__aexit__ = AsyncMock(return_value=False)
+
+        with patch(
+            "aiohttp.ClientSession.post", side_effect=[mock_hash, mock_order]
+        ) as mock_post:
+            await broker.send_order("005930", "BUY", 1, price=50000)
+
+        order_call = mock_post.call_args_list[1]
+        body = order_call[1].get("json", {})
+        assert body["ORD_DVSN"] == "00"
+
+    @pytest.mark.asyncio
+    async def test_market_order_ord_dvsn_is_01(self, broker: KISBroker) -> None:
+        """send_order with price=0 must use ORD_DVSN='01' (시장가)."""
+        mock_hash = AsyncMock()
+        mock_hash.status = 200
+        mock_hash.json = AsyncMock(return_value={"HASH": "h"})
+        mock_hash.__aenter__ = AsyncMock(return_value=mock_hash)
+        mock_hash.__aexit__ = AsyncMock(return_value=False)
+
+        mock_order = AsyncMock()
+        mock_order.status = 200
+        mock_order.json = AsyncMock(return_value={"rt_cd": "0"})
+        mock_order.__aenter__ = AsyncMock(return_value=mock_order)
+        mock_order.__aexit__ = AsyncMock(return_value=False)
+
+        with patch(
+            "aiohttp.ClientSession.post", side_effect=[mock_hash, mock_order]
+        ) as mock_post:
+            await broker.send_order("005930", "SELL", 1, price=0)
+
+        order_call = mock_post.call_args_list[1]
+        body = order_call[1].get("json", {})
+        assert body["ORD_DVSN"] == "01"
+        assert body["ORD_UNPR"] == "0"
--- a/tests/test_dashboard.py
+++ b/tests/test_dashboard.py
@@ -296,3 +296,23 @@ def test_scenarios_active_empty_when_no_matches(tmp_path: Path) -> None:
    get_active_scenarios = _endpoint(app, "/api/scenarios/active")
    body = get_active_scenarios(market="US", date_str="2026-02-14", limit=50)
    assert body["count"] == 0
+
+
+def test_pnl_history_all_markets(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_pnl_history = _endpoint(app, "/api/pnl/history")
+    body = get_pnl_history(days=30, market="all")
+    assert body["market"] == "all"
+    assert isinstance(body["labels"], list)
+    assert isinstance(body["pnl"], list)
+    assert len(body["labels"]) == len(body["pnl"])
+
+
+def test_pnl_history_market_filter(tmp_path: Path) -> None:
+    app = _app(tmp_path)
+    get_pnl_history = _endpoint(app, "/api/pnl/history")
+    body = get_pnl_history(days=30, market="KR")
+    assert body["market"] == "KR"
+    # KR has 1 trade with pnl=2.0
+    assert len(body["labels"]) >= 1
+    assert body["pnl"][0] == 2.0
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -14,6 +14,9 @@ from src.evolution.scorecard import DailyScorecard
 from src.logging.decision_logger import DecisionLogger
 from src.main import (
    _apply_dashboard_flag,
+    _determine_order_quantity,
+    _extract_held_codes_from_balance,
+    _extract_held_qty_from_balance,
    _handle_market_close,
    _run_context_scheduler,
    _run_evolution_loop,
@@ -68,6 +71,219 @@ def _make_sell_match(stock_code: str = "005930") -> ScenarioMatch:
    )


+class TestExtractHeldQtyFromBalance:
+    """Tests for _extract_held_qty_from_balance()."""
+
+    def _domestic_balance(self, stock_code: str, ord_psbl_qty: int) -> dict:
+        return {
+            "output1": [{"pdno": stock_code, "ord_psbl_qty": str(ord_psbl_qty)}],
+            "output2": [{"dnca_tot_amt": "1000000"}],
+        }
+
+    def test_domestic_returns_ord_psbl_qty(self) -> None:
+        balance = self._domestic_balance("005930", 7)
+        assert _extract_held_qty_from_balance(balance, "005930", is_domestic=True) == 7
+
+    def test_domestic_fallback_to_hldg_qty(self) -> None:
+        balance = {"output1": [{"pdno": "005930", "hldg_qty": "3"}]}
+        assert _extract_held_qty_from_balance(balance, "005930", is_domestic=True) == 3
+
+    def test_domestic_returns_zero_when_not_found(self) -> None:
+        balance = self._domestic_balance("005930", 5)
+        assert _extract_held_qty_from_balance(balance, "000660", is_domestic=True) == 0
+
+    def test_domestic_returns_zero_when_output1_empty(self) -> None:
+        balance = {"output1": [], "output2": [{}]}
+        assert _extract_held_qty_from_balance(balance, "005930", is_domestic=True) == 0
+
+    def test_overseas_returns_ovrs_cblc_qty(self) -> None:
+        balance = {"output1": [{"ovrs_pdno": "AAPL", "ovrs_cblc_qty": "10"}]}
+        assert _extract_held_qty_from_balance(balance, "AAPL", is_domestic=False) == 10
+
+    def test_overseas_fallback_to_hldg_qty(self) -> None:
+        balance = {"output1": [{"ovrs_pdno": "AAPL", "hldg_qty": "4"}]}
+        assert _extract_held_qty_from_balance(balance, "AAPL", is_domestic=False) == 4
+
+    def test_case_insensitive_match(self) -> None:
+        balance = {"output1": [{"pdno": "005930", "ord_psbl_qty": "2"}]}
+        assert _extract_held_qty_from_balance(balance, "005930", is_domestic=True) == 2
+
+
+class TestExtractHeldCodesFromBalance:
+    """Tests for _extract_held_codes_from_balance()."""
+
+    def test_returns_codes_with_positive_qty(self) -> None:
+        balance = {
+            "output1": [
+                {"pdno": "005930", "ord_psbl_qty": "5"},
+                {"pdno": "000660", "ord_psbl_qty": "3"},
+            ]
+        }
+        result = _extract_held_codes_from_balance(balance, is_domestic=True)
+        assert set(result) == {"005930", "000660"}
+
+    def test_excludes_zero_qty_holdings(self) -> None:
+        balance = {
+            "output1": [
+                {"pdno": "005930", "ord_psbl_qty": "0"},
+                {"pdno": "000660", "ord_psbl_qty": "2"},
+            ]
+        }
+        result = _extract_held_codes_from_balance(balance, is_domestic=True)
+        assert "005930" not in result
+        assert "000660" in result
+
+    def test_returns_empty_when_output1_missing(self) -> None:
+        balance: dict = {}
+        assert _extract_held_codes_from_balance(balance, is_domestic=True) == []
+
+    def test_overseas_uses_ovrs_pdno(self) -> None:
+        balance = {"output1": [{"ovrs_pdno": "AAPL", "ovrs_cblc_qty": "3"}]}
+        result = _extract_held_codes_from_balance(balance, is_domestic=False)
+        assert result == ["AAPL"]
+
+
+class TestDetermineOrderQuantity:
+    """Test _determine_order_quantity() — SELL uses broker_held_qty."""
+
+    def test_sell_returns_broker_held_qty(self) -> None:
+        result = _determine_order_quantity(
+            action="SELL",
+            current_price=105.0,
+            total_cash=50000.0,
+            candidate=None,
+            settings=None,
+            broker_held_qty=7,
+        )
+        assert result == 7
+
+    def test_sell_returns_zero_when_broker_qty_zero(self) -> None:
+        result = _determine_order_quantity(
+            action="SELL",
+            current_price=105.0,
+            total_cash=50000.0,
+            candidate=None,
+            settings=None,
+            broker_held_qty=0,
+        )
+        assert result == 0
+
+    def test_buy_without_position_sizing_returns_one(self) -> None:
+        result = _determine_order_quantity(
+            action="BUY",
+            current_price=50000.0,
+            total_cash=1000000.0,
+            candidate=None,
+            settings=None,
+        )
+        assert result == 1
+
+    def test_buy_with_zero_cash_returns_zero(self) -> None:
+        result = _determine_order_quantity(
+            action="BUY",
+            current_price=50000.0,
+            total_cash=0.0,
+            candidate=None,
+            settings=None,
+        )
+        assert result == 0
+
+    def test_buy_with_position_sizing_calculates_correctly(self) -> None:
+        settings = MagicMock(spec=Settings)
+        settings.POSITION_SIZING_ENABLED = True
+        settings.POSITION_VOLATILITY_TARGET_SCORE = 50.0
+        settings.POSITION_BASE_ALLOCATION_PCT = 10.0
+        settings.POSITION_MAX_ALLOCATION_PCT = 30.0
+        settings.POSITION_MIN_ALLOCATION_PCT = 1.0
+        # 1,000,000 * 10% = 100,000 budget // 50,000 price = 2 shares
+        result = _determine_order_quantity(
+            action="BUY",
+            current_price=50000.0,
+            total_cash=1000000.0,
+            candidate=None,
+            settings=settings,
+        )
+        assert result == 2
+
+    def test_determine_order_quantity_uses_playbook_allocation_pct(self) -> None:
+        """playbook_allocation_pct should take priority over volatility-based sizing."""
+        settings = MagicMock(spec=Settings)
+        settings.POSITION_SIZING_ENABLED = True
+        settings.POSITION_MAX_ALLOCATION_PCT = 30.0
+        settings.POSITION_MIN_ALLOCATION_PCT = 1.0
+        # playbook says 20%, confidence 80 → scale=1.0 → 20%
+        # 1,000,000 * 20% = 200,000 // 50,000 price = 4 shares
+        result = _determine_order_quantity(
+            action="BUY",
+            current_price=50000.0,
+            total_cash=1000000.0,
+            candidate=None,
+            settings=settings,
+            playbook_allocation_pct=20.0,
+            scenario_confidence=80,
+        )
+        assert result == 4
+
+    def test_determine_order_quantity_confidence_scales_allocation(self) -> None:
+        """Higher confidence should produce a larger allocation (up to max)."""
+        settings = MagicMock(spec=Settings)
+        settings.POSITION_SIZING_ENABLED = True
+        settings.POSITION_MAX_ALLOCATION_PCT = 30.0
+        settings.POSITION_MIN_ALLOCATION_PCT = 1.0
+        # confidence 96 → scale=1.2 → 10% * 1.2 = 12%
+        # 1,000,000 * 12% = 120,000 // 50,000 price = 2 shares
+        result = _determine_order_quantity(
+            action="BUY",
+            current_price=50000.0,
+            total_cash=1000000.0,
+            candidate=None,
+            settings=settings,
+            playbook_allocation_pct=10.0,
+            scenario_confidence=96,
+        )
+        # scale = 96/80 = 1.2 → effective_pct = 12.0
+        # budget = 1_000_000 * 0.12 = 120_000 → qty = 120_000 // 50_000 = 2
+        assert result == 2
+
+    def test_determine_order_quantity_confidence_clamped_to_max(self) -> None:
+        """Confidence scaling should not exceed POSITION_MAX_ALLOCATION_PCT."""
+        settings = MagicMock(spec=Settings)
+        settings.POSITION_SIZING_ENABLED = True
+        settings.POSITION_MAX_ALLOCATION_PCT = 15.0
+        settings.POSITION_MIN_ALLOCATION_PCT = 1.0
+        # playbook 20% * scale 1.5 = 30% → clamped to 15%
+        # 1,000,000 * 15% = 150,000 // 50,000 price = 3 shares
+        result = _determine_order_quantity(
+            action="BUY",
+            current_price=50000.0,
+            total_cash=1000000.0,
+            candidate=None,
+            settings=settings,
+            playbook_allocation_pct=20.0,
+            scenario_confidence=120,  # extreme → scale = 1.5
+        )
+        assert result == 3
+
+    def test_determine_order_quantity_fallback_when_no_playbook(self) -> None:
+        """Without playbook_allocation_pct, falls back to volatility-based sizing."""
+        settings = MagicMock(spec=Settings)
+        settings.POSITION_SIZING_ENABLED = True
+        settings.POSITION_VOLATILITY_TARGET_SCORE = 50.0
+        settings.POSITION_BASE_ALLOCATION_PCT = 10.0
+        settings.POSITION_MAX_ALLOCATION_PCT = 30.0
+        settings.POSITION_MIN_ALLOCATION_PCT = 1.0
+        # Same as test_buy_with_position_sizing_calculates_correctly (no playbook)
+        result = _determine_order_quantity(
+            action="BUY",
+            current_price=50000.0,
+            total_cash=1000000.0,
+            candidate=None,
+            settings=settings,
+            playbook_allocation_pct=None,  # explicit None → fallback
+        )
+        assert result == 2
+
+
 class TestSafeFloat:
    """Test safe_float() helper function."""

@@ -111,15 +327,7 @@ class TestTradingCycleTelegramIntegration:
    def mock_broker(self) -> MagicMock:
        """Create mock broker."""
        broker = MagicMock()
-        broker.get_orderbook = AsyncMock(
-            return_value={
-                "output1": {
-                    "stck_prpr": "50000",
-                    "frgn_ntby_qty": "100",
-                    "prdy_ctrt": "1.23",
-                }
-            }
-        )
+        broker.get_current_price = AsyncMock(return_value=(50000.0, 1.23, 100.0))
        broker.get_balance = AsyncMock(
            return_value={
                "output2": [
@@ -823,11 +1031,7 @@ class TestScenarioEngineIntegration:
    def mock_broker(self) -> MagicMock:
        """Create mock broker with standard domestic data."""
        broker = MagicMock()
-        broker.get_orderbook = AsyncMock(
-            return_value={
-                "output1": {"stck_prpr": "50000", "frgn_ntby_qty": "100", "prdy_ctrt": "2.50"}
-            }
-        )
+        broker.get_current_price = AsyncMock(return_value=(50000.0, 2.50, 100.0))
        broker.get_balance = AsyncMock(
            return_value={
                "output2": [
@@ -1249,18 +1453,17 @@ async def test_sell_updates_original_buy_decision_outcome() -> None:
    )

    broker = MagicMock()
-    broker.get_orderbook = AsyncMock(
-        return_value={"output1": {"stck_prpr": "120", "frgn_ntby_qty": "0"}}
-    )
+    broker.get_current_price = AsyncMock(return_value=(120.0, 0.0, 0.0))
    broker.get_balance = AsyncMock(
        return_value={
+            "output1": [{"pdno": "005930", "ord_psbl_qty": "1"}],
            "output2": [
                {
                    "tot_evlu_amt": "100000",
                    "dnca_tot_amt": "10000",
                    "pchs_amt_smtl_amt": "90000",
                }
-            ]
+            ],
        }
    )
    broker.send_order = AsyncMock(return_value={"msg1": "OK"})
@@ -1341,18 +1544,17 @@ async def test_hold_overridden_to_sell_when_stop_loss_triggered() -> None:
    )

    broker = MagicMock()
-    broker.get_orderbook = AsyncMock(
-        return_value={"output1": {"stck_prpr": "95", "frgn_ntby_qty": "0", "prdy_ctrt": "-5.0"}}
-    )
+    broker.get_current_price = AsyncMock(return_value=(95.0, -5.0, 0.0))
    broker.get_balance = AsyncMock(
        return_value={
+            "output1": [{"pdno": "005930", "ord_psbl_qty": "1"}],
            "output2": [
                {
                    "tot_evlu_amt": "100000",
                    "dnca_tot_amt": "10000",
                    "pchs_amt_smtl_amt": "90000",
                }
-            ]
+            ],
        }
    )
    broker.send_order = AsyncMock(return_value={"msg1": "OK"})
@@ -1412,6 +1614,318 @@ async def test_hold_overridden_to_sell_when_stop_loss_triggered() -> None:
    assert broker.send_order.call_args.kwargs["order_type"] == "SELL"


+@pytest.mark.asyncio
+async def test_hold_overridden_to_sell_when_take_profit_triggered() -> None:
+    """HOLD decision should be overridden to SELL when take-profit threshold is reached."""
+    db_conn = init_db(":memory:")
+    decision_logger = DecisionLogger(db_conn)
+
+    buy_decision_id = decision_logger.log_decision(
+        stock_code="005930",
+        market="KR",
+        exchange_code="KRX",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        context_snapshot={},
+        input_data={},
+    )
+    log_trade(
+        conn=db_conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        quantity=1,
+        price=100.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id=buy_decision_id,
+    )
+
+    broker = MagicMock()
+    # Current price 106.0 → +6% gain, above take_profit_pct=3.0
+    broker.get_current_price = AsyncMock(return_value=(106.0, 6.0, 0.0))
+    broker.get_balance = AsyncMock(
+        return_value={
+            "output1": [{"pdno": "005930", "ord_psbl_qty": "1"}],
+            "output2": [
+                {
+                    "tot_evlu_amt": "100000",
+                    "dnca_tot_amt": "10000",
+                    "pchs_amt_smtl_amt": "90000",
+                }
+            ],
+        }
+    )
+    broker.send_order = AsyncMock(return_value={"msg1": "OK"})
+
+    scenario = StockScenario(
+        condition=StockCondition(rsi_below=30),
+        action=ScenarioAction.BUY,
+        confidence=88,
+        stop_loss_pct=-2.0,
+        take_profit_pct=3.0,
+        rationale="take profit policy",
+    )
+    playbook = DayPlaybook(
+        date=date(2026, 2, 8),
+        market="KR",
+        stock_playbooks=[
+            {"stock_code": "005930", "stock_name": "Samsung", "scenarios": [scenario]}
+        ],
+    )
+    engine = MagicMock(spec=ScenarioEngine)
+    engine.evaluate = MagicMock(return_value=_make_hold_match())
+
+    market = MagicMock()
+    market.name = "Korea"
+    market.code = "KR"
+    market.exchange_code = "KRX"
+    market.is_domestic = True
+
+    telegram = MagicMock()
+    telegram.notify_trade_execution = AsyncMock()
+    telegram.notify_fat_finger = AsyncMock()
+    telegram.notify_circuit_breaker = AsyncMock()
+    telegram.notify_scenario_matched = AsyncMock()
+
+    await trading_cycle(
+        broker=broker,
+        overseas_broker=MagicMock(),
+        scenario_engine=engine,
+        playbook=playbook,
+        risk=MagicMock(),
+        db_conn=db_conn,
+        decision_logger=decision_logger,
+        context_store=MagicMock(
+            get_latest_timeframe=MagicMock(return_value=None),
+            set_context=MagicMock(),
+        ),
+        criticality_assessor=MagicMock(
+            assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+            get_timeout=MagicMock(return_value=5.0),
+        ),
+        telegram=telegram,
+        market=market,
+        stock_code="005930",
+        scan_candidates={},
+    )
+
+    broker.send_order.assert_called_once()
+    assert broker.send_order.call_args.kwargs["order_type"] == "SELL"
+
+
+@pytest.mark.asyncio
+async def test_hold_not_overridden_when_between_stop_loss_and_take_profit() -> None:
+    """HOLD should remain HOLD when P&L is within stop-loss and take-profit bounds."""
+    db_conn = init_db(":memory:")
+    decision_logger = DecisionLogger(db_conn)
+
+    buy_decision_id = decision_logger.log_decision(
+        stock_code="005930",
+        market="KR",
+        exchange_code="KRX",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        context_snapshot={},
+        input_data={},
+    )
+    log_trade(
+        conn=db_conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        quantity=1,
+        price=100.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id=buy_decision_id,
+    )
+
+    broker = MagicMock()
+    # Current price 101.0 → +1% gain, within [-2%, +3%] range
+    broker.get_current_price = AsyncMock(return_value=(101.0, 1.0, 0.0))
+    broker.get_balance = AsyncMock(
+        return_value={
+            "output2": [
+                {
+                    "tot_evlu_amt": "100000",
+                    "dnca_tot_amt": "10000",
+                    "pchs_amt_smtl_amt": "90000",
+                }
+            ]
+        }
+    )
+    broker.send_order = AsyncMock(return_value={"msg1": "OK"})
+
+    scenario = StockScenario(
+        condition=StockCondition(rsi_below=30),
+        action=ScenarioAction.BUY,
+        confidence=88,
+        stop_loss_pct=-2.0,
+        take_profit_pct=3.0,
+        rationale="within range policy",
+    )
+    playbook = DayPlaybook(
+        date=date(2026, 2, 8),
+        market="KR",
+        stock_playbooks=[
+            {"stock_code": "005930", "stock_name": "Samsung", "scenarios": [scenario]}
+        ],
+    )
+    engine = MagicMock(spec=ScenarioEngine)
+    engine.evaluate = MagicMock(return_value=_make_hold_match())
+
+    market = MagicMock()
+    market.name = "Korea"
+    market.code = "KR"
+    market.exchange_code = "KRX"
+    market.is_domestic = True
+
+    telegram = MagicMock()
+    telegram.notify_trade_execution = AsyncMock()
+    telegram.notify_fat_finger = AsyncMock()
+    telegram.notify_circuit_breaker = AsyncMock()
+    telegram.notify_scenario_matched = AsyncMock()
+
+    await trading_cycle(
+        broker=broker,
+        overseas_broker=MagicMock(),
+        scenario_engine=engine,
+        playbook=playbook,
+        risk=MagicMock(),
+        db_conn=db_conn,
+        decision_logger=decision_logger,
+        context_store=MagicMock(
+            get_latest_timeframe=MagicMock(return_value=None),
+            set_context=MagicMock(),
+        ),
+        criticality_assessor=MagicMock(
+            assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+            get_timeout=MagicMock(return_value=5.0),
+        ),
+        telegram=telegram,
+        market=market,
+        stock_code="005930",
+        scan_candidates={},
+    )
+
+    broker.send_order.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_sell_order_uses_broker_balance_qty_not_db() -> None:
+    """SELL quantity must come from broker balance output1, not DB.
+
+    The DB records order quantity which may differ from actual fill quantity.
+    This test verifies that we use the broker-confirmed orderable quantity.
+    """
+    db_conn = init_db(":memory:")
+    decision_logger = DecisionLogger(db_conn)
+
+    buy_decision_id = decision_logger.log_decision(
+        stock_code="005930",
+        market="KR",
+        exchange_code="KRX",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        context_snapshot={},
+        input_data={},
+    )
+    # DB records 10 shares ordered — but only 5 actually filled (partial fill scenario)
+    log_trade(
+        conn=db_conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=90,
+        rationale="entry",
+        quantity=10,  # ordered quantity (may differ from fill)
+        price=100.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id=buy_decision_id,
+    )
+
+    broker = MagicMock()
+    # Stop-loss triggers (price dropped below -2%)
+    broker.get_current_price = AsyncMock(return_value=(95.0, -5.0, 0.0))
+    broker.get_balance = AsyncMock(
+        return_value={
+            # Broker confirms only 5 shares are actually orderable (partial fill)
+            "output1": [{"pdno": "005930", "ord_psbl_qty": "5"}],
+            "output2": [
+                {
+                    "tot_evlu_amt": "100000",
+                    "dnca_tot_amt": "10000",
+                    "pchs_amt_smtl_amt": "90000",
+                }
+            ],
+        }
+    )
+    broker.send_order = AsyncMock(return_value={"msg1": "OK"})
+
+    scenario = StockScenario(
+        condition=StockCondition(rsi_below=30),
+        action=ScenarioAction.BUY,
+        confidence=88,
+        stop_loss_pct=-2.0,
+        rationale="stop loss policy",
+    )
+    playbook = DayPlaybook(
+        date=date(2026, 2, 8),
+        market="KR",
+        stock_playbooks=[
+            {"stock_code": "005930", "stock_name": "Samsung", "scenarios": [scenario]}
+        ],
+    )
+    engine = MagicMock(spec=ScenarioEngine)
+    engine.evaluate = MagicMock(return_value=_make_hold_match())
+
+    market = MagicMock()
+    market.name = "Korea"
+    market.code = "KR"
+    market.exchange_code = "KRX"
+    market.is_domestic = True
+
+    telegram = MagicMock()
+    telegram.notify_trade_execution = AsyncMock()
+    telegram.notify_fat_finger = AsyncMock()
+    telegram.notify_circuit_breaker = AsyncMock()
+    telegram.notify_scenario_matched = AsyncMock()
+
+    await trading_cycle(
+        broker=broker,
+        overseas_broker=MagicMock(),
+        scenario_engine=engine,
+        playbook=playbook,
+        risk=MagicMock(),
+        db_conn=db_conn,
+        decision_logger=decision_logger,
+        context_store=MagicMock(
+            get_latest_timeframe=MagicMock(return_value=None),
+            set_context=MagicMock(),
+        ),
+        criticality_assessor=MagicMock(
+            assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+            get_timeout=MagicMock(return_value=5.0),
+        ),
+        telegram=telegram,
+        market=market,
+        stock_code="005930",
+        scan_candidates={},
+    )
+
+    broker.send_order.assert_called_once()
+    call_kwargs = broker.send_order.call_args.kwargs
+    assert call_kwargs["order_type"] == "SELL"
+    # Must use broker-confirmed qty (5), NOT DB-recorded ordered qty (10)
+    assert call_kwargs["quantity"] == 5
+
+
@pytest.mark.asyncio
 async def test_handle_market_close_runs_daily_review_flow() -> None:
    """Market close should aggregate, create scorecard, lessons, and notify."""
@@ -1678,3 +2192,284 @@ def test_start_dashboard_server_enabled_starts_thread() -> None:
    assert thread == mock_thread
    mock_thread_cls.assert_called_once()
    mock_thread.start.assert_called_once()
+
+
+# ---------------------------------------------------------------------------
+# market_outlook BUY confidence threshold tests (#173)
+# ---------------------------------------------------------------------------
+
+
+class TestMarketOutlookConfidenceThreshold:
+    """Tests for market_outlook-based BUY confidence suppression in trading_cycle."""
+
+    @pytest.fixture
+    def mock_broker(self) -> MagicMock:
+        broker = MagicMock()
+        broker.get_current_price = AsyncMock(return_value=(50000.0, 1.0, 0.0))
+        broker.get_balance = AsyncMock(
+            return_value={
+                "output2": [
+                    {
+                        "tot_evlu_amt": "10000000",
+                        "dnca_tot_amt": "5000000",
+                        "pchs_amt_smtl_amt": "9500000",
+                    }
+                ]
+            }
+        )
+        broker.send_order = AsyncMock(return_value={"msg1": "OK"})
+        return broker
+
+    @pytest.fixture
+    def mock_market(self) -> MagicMock:
+        market = MagicMock()
+        market.name = "Korea"
+        market.code = "KR"
+        market.exchange_code = "KRX"
+        market.is_domestic = True
+        return market
+
+    @pytest.fixture
+    def mock_telegram(self) -> MagicMock:
+        telegram = MagicMock()
+        telegram.notify_trade_execution = AsyncMock()
+        telegram.notify_scenario_matched = AsyncMock()
+        telegram.notify_fat_finger = AsyncMock()
+        return telegram
+
+    def _make_buy_match_with_confidence(
+        self, confidence: int, stock_code: str = "005930"
+    ) -> ScenarioMatch:
+        from src.strategy.models import StockScenario
+        scenario = StockScenario(
+            condition=StockCondition(rsi_below=30),
+            action=ScenarioAction.BUY,
+            confidence=confidence,
+            allocation_pct=10.0,
+        )
+        return ScenarioMatch(
+            stock_code=stock_code,
+            matched_scenario=scenario,
+            action=ScenarioAction.BUY,
+            confidence=confidence,
+            rationale="Test buy",
+        )
+
+    def _make_playbook_with_outlook(
+        self, outlook_str: str, market: str = "KR"
+    ) -> DayPlaybook:
+        from src.strategy.models import MarketOutlook
+        outlook_map = {
+            "bearish": MarketOutlook.BEARISH,
+            "bullish": MarketOutlook.BULLISH,
+            "neutral": MarketOutlook.NEUTRAL,
+            "neutral_to_bullish": MarketOutlook.NEUTRAL_TO_BULLISH,
+            "neutral_to_bearish": MarketOutlook.NEUTRAL_TO_BEARISH,
+        }
+        return DayPlaybook(
+            date=date(2026, 2, 20),
+            market=market,
+            market_outlook=outlook_map[outlook_str],
+        )
+
+    @pytest.mark.asyncio
+    async def test_bearish_outlook_raises_buy_confidence_threshold(
+        self,
+        mock_broker: MagicMock,
+        mock_market: MagicMock,
+        mock_telegram: MagicMock,
+    ) -> None:
+        """BUY with confidence 85 should be suppressed to HOLD in bearish market."""
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=self._make_buy_match_with_confidence(85))
+        playbook = self._make_playbook_with_outlook("bearish")
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="decision-id")
+
+        with patch("src.main.log_trade"):
+            await trading_cycle(
+                broker=mock_broker,
+                overseas_broker=MagicMock(),
+                scenario_engine=engine,
+                playbook=playbook,
+                risk=MagicMock(),
+                db_conn=MagicMock(),
+                decision_logger=decision_logger,
+                context_store=MagicMock(get_latest_timeframe=MagicMock(return_value=None)),
+                criticality_assessor=MagicMock(
+                    assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+                    get_timeout=MagicMock(return_value=5.0),
+                ),
+                telegram=mock_telegram,
+                market=mock_market,
+                stock_code="005930",
+                scan_candidates={},
+            )
+
+        # HOLD should be logged (not BUY) — check decision_logger was called with HOLD
+        call_args = decision_logger.log_decision.call_args
+        assert call_args is not None
+        assert call_args.kwargs["action"] == "HOLD"
+
+    @pytest.mark.asyncio
+    async def test_bearish_outlook_allows_high_confidence_buy(
+        self,
+        mock_broker: MagicMock,
+        mock_market: MagicMock,
+        mock_telegram: MagicMock,
+    ) -> None:
+        """BUY with confidence 92 should proceed in bearish market (threshold=90)."""
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=self._make_buy_match_with_confidence(92))
+        playbook = self._make_playbook_with_outlook("bearish")
+        risk = MagicMock()
+        risk.validate_order = MagicMock()
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="decision-id")
+
+        with patch("src.main.log_trade"):
+            await trading_cycle(
+                broker=mock_broker,
+                overseas_broker=MagicMock(),
+                scenario_engine=engine,
+                playbook=playbook,
+                risk=risk,
+                db_conn=MagicMock(),
+                decision_logger=decision_logger,
+                context_store=MagicMock(get_latest_timeframe=MagicMock(return_value=None)),
+                criticality_assessor=MagicMock(
+                    assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+                    get_timeout=MagicMock(return_value=5.0),
+                ),
+                telegram=mock_telegram,
+                market=mock_market,
+                stock_code="005930",
+                scan_candidates={},
+            )
+
+        call_args = decision_logger.log_decision.call_args
+        assert call_args is not None
+        assert call_args.kwargs["action"] == "BUY"
+
+    @pytest.mark.asyncio
+    async def test_bullish_outlook_lowers_buy_confidence_threshold(
+        self,
+        mock_broker: MagicMock,
+        mock_market: MagicMock,
+        mock_telegram: MagicMock,
+    ) -> None:
+        """BUY with confidence 77 should proceed in bullish market (threshold=75)."""
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=self._make_buy_match_with_confidence(77))
+        playbook = self._make_playbook_with_outlook("bullish")
+        risk = MagicMock()
+        risk.validate_order = MagicMock()
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="decision-id")
+
+        with patch("src.main.log_trade"):
+            await trading_cycle(
+                broker=mock_broker,
+                overseas_broker=MagicMock(),
+                scenario_engine=engine,
+                playbook=playbook,
+                risk=risk,
+                db_conn=MagicMock(),
+                decision_logger=decision_logger,
+                context_store=MagicMock(get_latest_timeframe=MagicMock(return_value=None)),
+                criticality_assessor=MagicMock(
+                    assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+                    get_timeout=MagicMock(return_value=5.0),
+                ),
+                telegram=mock_telegram,
+                market=mock_market,
+                stock_code="005930",
+                scan_candidates={},
+            )
+
+        call_args = decision_logger.log_decision.call_args
+        assert call_args is not None
+        assert call_args.kwargs["action"] == "BUY"
+
+    @pytest.mark.asyncio
+    async def test_bullish_outlook_suppresses_very_low_confidence_buy(
+        self,
+        mock_broker: MagicMock,
+        mock_market: MagicMock,
+        mock_telegram: MagicMock,
+    ) -> None:
+        """BUY with confidence 70 should be suppressed even in bullish market (threshold=75)."""
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=self._make_buy_match_with_confidence(70))
+        playbook = self._make_playbook_with_outlook("bullish")
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="decision-id")
+
+        with patch("src.main.log_trade"):
+            await trading_cycle(
+                broker=mock_broker,
+                overseas_broker=MagicMock(),
+                scenario_engine=engine,
+                playbook=playbook,
+                risk=MagicMock(),
+                db_conn=MagicMock(),
+                decision_logger=decision_logger,
+                context_store=MagicMock(get_latest_timeframe=MagicMock(return_value=None)),
+                criticality_assessor=MagicMock(
+                    assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+                    get_timeout=MagicMock(return_value=5.0),
+                ),
+                telegram=mock_telegram,
+                market=mock_market,
+                stock_code="005930",
+                scan_candidates={},
+            )
+
+        call_args = decision_logger.log_decision.call_args
+        assert call_args is not None
+        assert call_args.kwargs["action"] == "HOLD"
+
+    @pytest.mark.asyncio
+    async def test_neutral_outlook_uses_default_threshold(
+        self,
+        mock_broker: MagicMock,
+        mock_market: MagicMock,
+        mock_telegram: MagicMock,
+    ) -> None:
+        """BUY with confidence 82 should proceed in neutral market (default=80)."""
+        engine = MagicMock(spec=ScenarioEngine)
+        engine.evaluate = MagicMock(return_value=self._make_buy_match_with_confidence(82))
+        playbook = self._make_playbook_with_outlook("neutral")
+        risk = MagicMock()
+        risk.validate_order = MagicMock()
+
+        decision_logger = MagicMock()
+        decision_logger.log_decision = MagicMock(return_value="decision-id")
+
+        with patch("src.main.log_trade"):
+            await trading_cycle(
+                broker=mock_broker,
+                overseas_broker=MagicMock(),
+                scenario_engine=engine,
+                playbook=playbook,
+                risk=risk,
+                db_conn=MagicMock(),
+                decision_logger=decision_logger,
+                context_store=MagicMock(get_latest_timeframe=MagicMock(return_value=None)),
+                criticality_assessor=MagicMock(
+                    assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+                    get_timeout=MagicMock(return_value=5.0),
+                ),
+                telegram=mock_telegram,
+                market=mock_market,
+                stock_code="005930",
+                scan_candidates={},
+            )
+
+        call_args = decision_logger.log_decision.call_args
+        assert call_args is not None
+        assert call_args.kwargs["action"] == "BUY"
--- a/tests/test_pre_market_planner.py
+++ b/tests/test_pre_market_planner.py
@@ -830,3 +830,171 @@ class TestSmartFallbackPlaybook:
        ]
        assert len(buy_scenarios) == 1
        assert buy_scenarios[0].condition.volume_ratio_above == 2.0  # VOL_MULTIPLIER default
+
+
+# ---------------------------------------------------------------------------
+# Holdings in prompt (#170)
+# ---------------------------------------------------------------------------
+
+
+class TestHoldingsInPrompt:
+    """Tests for current_holdings parameter in generate_playbook / _build_prompt."""
+
+    def _make_holdings(self) -> list[dict]:
+        return [
+            {
+                "stock_code": "005930",
+                "name": "Samsung",
+                "qty": 10,
+                "entry_price": 71000.0,
+                "unrealized_pnl_pct": 2.3,
+                "holding_days": 3,
+            }
+        ]
+
+    def test_build_prompt_includes_holdings_section(self) -> None:
+        """Prompt should contain a Current Holdings section when holdings are given."""
+        planner = _make_planner()
+        candidates = [_candidate()]
+        holdings = self._make_holdings()
+
+        prompt = planner._build_prompt(
+            "KR",
+            candidates,
+            context_data={},
+            self_market_scorecard=None,
+            cross_market=None,
+            current_holdings=holdings,
+        )
+
+        assert "## Current Holdings" in prompt
+        assert "005930" in prompt
+        assert "+2.30%" in prompt
+        assert "보유 3일" in prompt
+
+    def test_build_prompt_no_holdings_omits_section(self) -> None:
+        """Prompt should NOT contain a Current Holdings section when holdings=None."""
+        planner = _make_planner()
+        candidates = [_candidate()]
+
+        prompt = planner._build_prompt(
+            "KR",
+            candidates,
+            context_data={},
+            self_market_scorecard=None,
+            cross_market=None,
+            current_holdings=None,
+        )
+
+        assert "## Current Holdings" not in prompt
+
+    def test_build_prompt_empty_holdings_omits_section(self) -> None:
+        """Empty list should also omit the holdings section."""
+        planner = _make_planner()
+        candidates = [_candidate()]
+
+        prompt = planner._build_prompt(
+            "KR",
+            candidates,
+            context_data={},
+            self_market_scorecard=None,
+            cross_market=None,
+            current_holdings=[],
+        )
+
+        assert "## Current Holdings" not in prompt
+
+    def test_build_prompt_holdings_instruction_included(self) -> None:
+        """Prompt should include instruction to generate scenarios for held stocks."""
+        planner = _make_planner()
+        candidates = [_candidate()]
+        holdings = self._make_holdings()
+
+        prompt = planner._build_prompt(
+            "KR",
+            candidates,
+            context_data={},
+            self_market_scorecard=None,
+            cross_market=None,
+            current_holdings=holdings,
+        )
+
+        assert "005930" in prompt
+        assert "SELL/HOLD" in prompt
+
+    @pytest.mark.asyncio
+    async def test_generate_playbook_passes_holdings_to_prompt(self) -> None:
+        """generate_playbook should pass current_holdings through to the prompt."""
+        planner = _make_planner()
+        candidates = [_candidate()]
+        holdings = self._make_holdings()
+
+        # Capture the actual prompt sent to Gemini
+        captured_prompts: list[str] = []
+        original_decide = planner._gemini.decide
+
+        async def capture_and_call(data: dict) -> TradeDecision:
+            captured_prompts.append(data.get("prompt_override", ""))
+            return await original_decide(data)
+
+        planner._gemini.decide = capture_and_call  # type: ignore[method-assign]
+
+        await planner.generate_playbook(
+            "KR", candidates, today=date(2026, 2, 8), current_holdings=holdings
+        )
+
+        assert len(captured_prompts) == 1
+        assert "## Current Holdings" in captured_prompts[0]
+        assert "005930" in captured_prompts[0]
+
+    @pytest.mark.asyncio
+    async def test_holdings_stock_allowed_in_parse_response(self) -> None:
+        """Holdings stocks not in candidates list should be accepted in the response."""
+        holding_code = "000660"  # Not in candidates
+        stocks = [
+            {
+                "stock_code": "005930",  # candidate
+                "scenarios": [
+                    {
+                        "condition": {"rsi_below": 30},
+                        "action": "BUY",
+                        "confidence": 85,
+                        "rationale": "oversold",
+                    }
+                ],
+            },
+            {
+                "stock_code": holding_code,  # holding only
+                "scenarios": [
+                    {
+                        "condition": {"price_change_pct_below": -2.0},
+                        "action": "SELL",
+                        "confidence": 90,
+                        "rationale": "stop-loss",
+                    }
+                ],
+            },
+        ]
+        planner = _make_planner(gemini_response=_gemini_response_json(stocks=stocks))
+        candidates = [_candidate()]  # only 005930
+        holdings = [
+            {
+                "stock_code": holding_code,
+                "name": "SK Hynix",
+                "qty": 5,
+                "entry_price": 180000.0,
+                "unrealized_pnl_pct": -1.5,
+                "holding_days": 7,
+            }
+        ]
+
+        pb = await planner.generate_playbook(
+            "KR",
+            candidates,
+            today=date(2026, 2, 8),
+            current_holdings=holdings,
+        )
+
+        codes = [sp.stock_code for sp in pb.stock_playbooks]
+        assert "005930" in codes
+        assert holding_code in codes
--- a/tests/test_scenario_engine.py
+++ b/tests/test_scenario_engine.py
@@ -440,3 +440,135 @@ class TestEvaluate:
        assert result.action == ScenarioAction.BUY
        assert result.match_details["rsi"] == 25.0
        assert isinstance(result.match_details["rsi"], float)
+
+
+# ---------------------------------------------------------------------------
+# Position-aware condition tests (#171)
+# ---------------------------------------------------------------------------
+
+
+class TestPositionAwareConditions:
+    """Tests for unrealized_pnl_pct and holding_days condition fields."""
+
+    def test_evaluate_condition_unrealized_pnl_above_matches(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """unrealized_pnl_pct_above should match when P&L exceeds threshold."""
+        condition = StockCondition(unrealized_pnl_pct_above=3.0)
+        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": 5.0}) is True
+
+    def test_evaluate_condition_unrealized_pnl_above_no_match(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """unrealized_pnl_pct_above should NOT match when P&L is below threshold."""
+        condition = StockCondition(unrealized_pnl_pct_above=3.0)
+        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": 2.0}) is False
+
+    def test_evaluate_condition_unrealized_pnl_below_matches(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """unrealized_pnl_pct_below should match when P&L is under threshold."""
+        condition = StockCondition(unrealized_pnl_pct_below=-2.0)
+        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": -3.5}) is True
+
+    def test_evaluate_condition_unrealized_pnl_below_no_match(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """unrealized_pnl_pct_below should NOT match when P&L is above threshold."""
+        condition = StockCondition(unrealized_pnl_pct_below=-2.0)
+        assert engine.evaluate_condition(condition, {"unrealized_pnl_pct": -1.0}) is False
+
+    def test_evaluate_condition_holding_days_above_matches(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """holding_days_above should match when position held longer than threshold."""
+        condition = StockCondition(holding_days_above=5)
+        assert engine.evaluate_condition(condition, {"holding_days": 7}) is True
+
+    def test_evaluate_condition_holding_days_above_no_match(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """holding_days_above should NOT match when position held shorter."""
+        condition = StockCondition(holding_days_above=5)
+        assert engine.evaluate_condition(condition, {"holding_days": 3}) is False
+
+    def test_evaluate_condition_holding_days_below_matches(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """holding_days_below should match when position held fewer days."""
+        condition = StockCondition(holding_days_below=3)
+        assert engine.evaluate_condition(condition, {"holding_days": 1}) is True
+
+    def test_evaluate_condition_holding_days_below_no_match(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """holding_days_below should NOT match when held more days."""
+        condition = StockCondition(holding_days_below=3)
+        assert engine.evaluate_condition(condition, {"holding_days": 5}) is False
+
+    def test_combined_pnl_and_holding_days(self, engine: ScenarioEngine) -> None:
+        """Combined position-aware conditions should AND-evaluate correctly."""
+        condition = StockCondition(
+            unrealized_pnl_pct_above=3.0,
+            holding_days_above=5,
+        )
+        # Both met → match
+        assert engine.evaluate_condition(
+            condition,
+            {"unrealized_pnl_pct": 4.5, "holding_days": 7},
+        ) is True
+        # Only pnl met → no match
+        assert engine.evaluate_condition(
+            condition,
+            {"unrealized_pnl_pct": 4.5, "holding_days": 3},
+        ) is False
+
+    def test_missing_unrealized_pnl_does_not_match(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """Missing unrealized_pnl_pct key should not match the condition."""
+        condition = StockCondition(unrealized_pnl_pct_above=3.0)
+        assert engine.evaluate_condition(condition, {}) is False
+
+    def test_missing_holding_days_does_not_match(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """Missing holding_days key should not match the condition."""
+        condition = StockCondition(holding_days_above=5)
+        assert engine.evaluate_condition(condition, {}) is False
+
+    def test_match_details_includes_position_fields(
+        self, engine: ScenarioEngine
+    ) -> None:
+        """match_details should include position fields when condition specifies them."""
+        pb = _playbook(
+            scenarios=[
+                StockScenario(
+                    condition=StockCondition(unrealized_pnl_pct_above=3.0),
+                    action=ScenarioAction.SELL,
+                    confidence=90,
+                    rationale="Take profit",
+                )
+            ]
+        )
+        result = engine.evaluate(
+            pb,
+            "005930",
+            {"unrealized_pnl_pct": 5.0},
+            {},
+        )
+        assert result.action == ScenarioAction.SELL
+        assert "unrealized_pnl_pct" in result.match_details
+        assert result.match_details["unrealized_pnl_pct"] == 5.0
+
+    def test_position_conditions_parse_from_planner(self) -> None:
+        """StockCondition should accept and store new fields from JSON parsing."""
+        condition = StockCondition(
+            unrealized_pnl_pct_above=3.0,
+            unrealized_pnl_pct_below=None,
+            holding_days_above=5,
+            holding_days_below=None,
+        )
+        assert condition.unrealized_pnl_pct_above == 3.0
+        assert condition.holding_days_above == 5
+        assert condition.has_any_condition() is True
--- a/tests/test_telegram.py
+++ b/tests/test_telegram.py
@@ -5,7 +5,7 @@ from unittest.mock import AsyncMock, patch
 import aiohttp
 import pytest

-from src.notifications.telegram_client import NotificationPriority, TelegramClient
+from src.notifications.telegram_client import NotificationFilter, NotificationPriority, TelegramClient


 class TestTelegramClientInit:
@@ -481,3 +481,187 @@ class TestClientCleanup:

        # Should not raise exception
        await client.close()
+
+
+class TestNotificationFilter:
+    """Test granular notification filter behavior."""
+
+    def test_default_filter_allows_all(self) -> None:
+        """Default NotificationFilter has all flags enabled."""
+        f = NotificationFilter()
+        assert f.trades is True
+        assert f.market_open_close is True
+        assert f.fat_finger is True
+        assert f.system_events is True
+        assert f.playbook is True
+        assert f.scenario_match is True
+        assert f.errors is True
+
+    def test_client_uses_default_filter_when_none_given(self) -> None:
+        """TelegramClient creates a default NotificationFilter when none provided."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        assert isinstance(client._filter, NotificationFilter)
+        assert client._filter.scenario_match is True
+
+    def test_client_stores_provided_filter(self) -> None:
+        """TelegramClient stores a custom NotificationFilter."""
+        nf = NotificationFilter(scenario_match=False, trades=False)
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        assert client._filter.scenario_match is False
+        assert client._filter.trades is False
+        assert client._filter.market_open_close is True  # default still True
+
+    @pytest.mark.asyncio
+    async def test_scenario_match_filtered_does_not_send(self) -> None:
+        """notify_scenario_matched skips send when scenario_match=False."""
+        nf = NotificationFilter(scenario_match=False)
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        with patch("aiohttp.ClientSession.post") as mock_post:
+            await client.notify_scenario_matched(
+                stock_code="005930", action="BUY", condition_summary="rsi<30", confidence=85.0
+            )
+            mock_post.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_trades_filtered_does_not_send(self) -> None:
+        """notify_trade_execution skips send when trades=False."""
+        nf = NotificationFilter(trades=False)
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        with patch("aiohttp.ClientSession.post") as mock_post:
+            await client.notify_trade_execution(
+                stock_code="005930", market="KR", action="BUY",
+                quantity=10, price=70000.0, confidence=85.0
+            )
+            mock_post.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_market_open_close_filtered_does_not_send(self) -> None:
+        """notify_market_open/close skip send when market_open_close=False."""
+        nf = NotificationFilter(market_open_close=False)
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        with patch("aiohttp.ClientSession.post") as mock_post:
+            await client.notify_market_open("Korea")
+            await client.notify_market_close("Korea", pnl_pct=1.5)
+            mock_post.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_circuit_breaker_always_sends_regardless_of_filter(self) -> None:
+        """notify_circuit_breaker always sends (no filter flag)."""
+        nf = NotificationFilter(
+            trades=False, market_open_close=False, fat_finger=False,
+            system_events=False, playbook=False, scenario_match=False, errors=False,
+        )
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        mock_resp = AsyncMock()
+        mock_resp.status = 200
+        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
+        mock_resp.__aexit__ = AsyncMock(return_value=False)
+
+        with patch("aiohttp.ClientSession.post", return_value=mock_resp) as mock_post:
+            await client.notify_circuit_breaker(pnl_pct=-3.5, threshold=-3.0)
+            assert mock_post.call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_errors_filtered_does_not_send(self) -> None:
+        """notify_error skips send when errors=False."""
+        nf = NotificationFilter(errors=False)
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        with patch("aiohttp.ClientSession.post") as mock_post:
+            await client.notify_error("TestError", "something went wrong", "KR")
+            mock_post.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_playbook_filtered_does_not_send(self) -> None:
+        """notify_playbook_generated/failed skip send when playbook=False."""
+        nf = NotificationFilter(playbook=False)
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        with patch("aiohttp.ClientSession.post") as mock_post:
+            await client.notify_playbook_generated("KR", 3, 10, 1200)
+            await client.notify_playbook_failed("KR", "timeout")
+            mock_post.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_system_events_filtered_does_not_send(self) -> None:
+        """notify_system_start/shutdown skip send when system_events=False."""
+        nf = NotificationFilter(system_events=False)
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        with patch("aiohttp.ClientSession.post") as mock_post:
+            await client.notify_system_start("paper", ["KR"])
+            await client.notify_system_shutdown("Normal shutdown")
+            mock_post.assert_not_called()
+
+    def test_set_flag_valid_key(self) -> None:
+        """set_flag returns True and updates field for a known key."""
+        nf = NotificationFilter()
+        assert nf.set_flag("scenario", False) is True
+        assert nf.scenario_match is False
+
+    def test_set_flag_invalid_key(self) -> None:
+        """set_flag returns False for an unknown key."""
+        nf = NotificationFilter()
+        assert nf.set_flag("unknown_key", False) is False
+
+    def test_as_dict_keys_match_KEYS(self) -> None:
+        """as_dict() returns every key defined in KEYS."""
+        nf = NotificationFilter()
+        d = nf.as_dict()
+        assert set(d.keys()) == set(NotificationFilter.KEYS.keys())
+
+    def test_set_notification_valid_key(self) -> None:
+        """TelegramClient.set_notification toggles filter at runtime."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        assert client._filter.scenario_match is True
+        assert client.set_notification("scenario", False) is True
+        assert client._filter.scenario_match is False
+
+    def test_set_notification_all_off(self) -> None:
+        """set_notification('all', False) disables every filter flag."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        assert client.set_notification("all", False) is True
+        for v in client.filter_status().values():
+            assert v is False
+
+    def test_set_notification_all_on(self) -> None:
+        """set_notification('all', True) enables every filter flag."""
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True,
+            notification_filter=NotificationFilter(
+                trades=False, market_open_close=False, scenario_match=False,
+                fat_finger=False, system_events=False, playbook=False, errors=False,
+            ),
+        )
+        assert client.set_notification("all", True) is True
+        for v in client.filter_status().values():
+            assert v is True
+
+    def test_set_notification_unknown_key(self) -> None:
+        """set_notification returns False for an unknown key."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        assert client.set_notification("unknown", False) is False
+
+    def test_filter_status_reflects_current_state(self) -> None:
+        """filter_status() matches the current NotificationFilter state."""
+        nf = NotificationFilter(trades=False, scenario_match=False)
+        client = TelegramClient(
+            bot_token="123:abc", chat_id="456", enabled=True, notification_filter=nf
+        )
+        status = client.filter_status()
+        assert status["trades"] is False
+        assert status["scenario"] is False
+        assert status["market"] is True
--- a/tests/test_telegram_commands.py
+++ b/tests/test_telegram_commands.py
@@ -875,3 +875,139 @@ class TestGetUpdates:
            updates = await handler._get_updates()

            assert updates == []
+
+    @pytest.mark.asyncio
+    async def test_get_updates_409_stops_polling(self) -> None:
+        """409 Conflict response stops the poller (_running = False) and returns empty list."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+        handler._running = True  # simulate active poller
+
+        mock_resp = AsyncMock()
+        mock_resp.status = 409
+        mock_resp.text = AsyncMock(
+            return_value='{"ok":false,"error_code":409,"description":"Conflict"}'
+        )
+        mock_resp.__aenter__ = AsyncMock(return_value=mock_resp)
+        mock_resp.__aexit__ = AsyncMock(return_value=False)
+
+        with patch("aiohttp.ClientSession.post", return_value=mock_resp):
+            updates = await handler._get_updates()
+
+        assert updates == []
+        assert handler._running is False  # poller stopped
+
+    @pytest.mark.asyncio
+    async def test_poll_loop_exits_after_409(self) -> None:
+        """_poll_loop exits naturally after _running is set to False by a 409 response."""
+        import asyncio as _asyncio
+
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        call_count = 0
+
+        async def mock_get_updates_409() -> list[dict]:
+            nonlocal call_count
+            call_count += 1
+            # Simulate 409 stopping the poller
+            handler._running = False
+            return []
+
+        handler._get_updates = mock_get_updates_409  # type: ignore[method-assign]
+
+        handler._running = True
+        task = _asyncio.create_task(handler._poll_loop())
+        await _asyncio.wait_for(task, timeout=2.0)
+
+        # _get_updates called exactly once, then loop exited
+        assert call_count == 1
+        assert handler._running is False
+
+
+class TestCommandWithArgs:
+    """Test register_command_with_args and argument dispatch."""
+
+    def test_register_command_with_args_stored(self) -> None:
+        """register_command_with_args stores handler in _commands_with_args."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        async def my_handler(args: list[str]) -> None:
+            pass
+
+        handler.register_command_with_args("notify", my_handler)
+        assert "notify" in handler._commands_with_args
+        assert handler._commands_with_args["notify"] is my_handler
+
+    @pytest.mark.asyncio
+    async def test_args_handler_receives_arguments(self) -> None:
+        """Args handler is called with the trailing tokens."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        received: list[list[str]] = []
+
+        async def capture(args: list[str]) -> None:
+            received.append(args)
+
+        handler.register_command_with_args("notify", capture)
+
+        update = {
+            "message": {
+                "chat": {"id": "456"},
+                "text": "/notify scenario off",
+            }
+        }
+        await handler._handle_update(update)
+        assert received == [["scenario", "off"]]
+
+    @pytest.mark.asyncio
+    async def test_args_handler_takes_priority_over_no_args_handler(self) -> None:
+        """When both handlers exist for same command, args handler wins."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        no_args_called = []
+        args_called = []
+
+        async def no_args_handler() -> None:
+            no_args_called.append(True)
+
+        async def args_handler(args: list[str]) -> None:
+            args_called.append(args)
+
+        handler.register_command("notify", no_args_handler)
+        handler.register_command_with_args("notify", args_handler)
+
+        update = {
+            "message": {
+                "chat": {"id": "456"},
+                "text": "/notify all off",
+            }
+        }
+        await handler._handle_update(update)
+        assert args_called == [["all", "off"]]
+        assert no_args_called == []
+
+    @pytest.mark.asyncio
+    async def test_args_handler_with_no_trailing_args(self) -> None:
+        """/notify with no args still dispatches to args handler with empty list."""
+        client = TelegramClient(bot_token="123:abc", chat_id="456", enabled=True)
+        handler = TelegramCommandHandler(client)
+
+        received: list[list[str]] = []
+
+        async def capture(args: list[str]) -> None:
+            received.append(args)
+
+        handler.register_command_with_args("notify", capture)
+
+        update = {
+            "message": {
+                "chat": {"id": "456"},
+                "text": "/notify",
+            }
+        }
+        await handler._handle_update(update)
+        assert received == [[]]
Author	SHA1	Message	Date
agentson	aceba86186	fix: Telegram 409 감지 시 백오프 대신 polling 즉시 종료 (#180 ) Some checks failed CI / test (pull_request) Has been cancelled Details 409 충돌 감지 시 30초 백오프 후 재시도하는 방식에서 _running = False로 polling을 즉시 중단하는 방식으로 변경. 다중 인스턴스가 실행 중인 경우 재시도는 의미 없고 충돌만 반복됨. 이제 409 발생 시 이 프로세스의 Telegram 명령어 polling을 완전히 비활성화. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 09:35:33 +09:00
agentson	77577f3f4d	fix: Telegram 409 충돌 시 WARNING 로그 + 30초 백오프 적용 (#180 ) Some checks failed CI / test (pull_request) Has been cancelled Details 다중 인스턴스 실행 시 Telegram getUpdates 409 응답을 ERROR가 아닌 WARNING으로 처리하고, 30초 동안 polling을 일시 중단하여 충돌을 완화. - _conflict_backoff_until 속성 추가 - 409 감지 시 명확한 "another instance is polling" 메시지 출력 - poll_loop에서 백오프 활성 중 polling 스킵 - TestGetUpdates에 409 관련 테스트 2개 추가 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 09:31:04 +09:00
jihoson	bd2b3241b2	Merge pull request 'feat: use market_outlook to adjust BUY confidence threshold (#173 )' (#177 ) from feature/issue-173-market-outlook-threshold into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #177	2026-02-20 08:38:52 +09:00
jihoson	561faaaafa	Merge pull request 'feat: use playbook allocation_pct in position sizing (#172 )' (#176 ) from feature/issue-172-playbook-allocation-sizing into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #176	2026-02-20 08:37:59 +09:00
jihoson	a33d6a145f	Merge pull request 'feat: add position-aware conditions to StockCondition (#171 )' (#175 ) from feature/issue-171-position-aware-conditions into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #175	2026-02-20 08:36:07 +09:00
jihoson	7e6c912214	Merge pull request 'feat: include current holdings in pre-market AI prompt (#170 )' (#174 ) from feature/issue-170-holdings-in-prompt into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #174	2026-02-20 08:35:16 +09:00
agentson	d6edbc0fa2	feat: use market_outlook to adjust BUY confidence threshold (#173 ) Some checks failed CI / test (pull_request) Has been cancelled Details - Import MarketOutlook at module level in main.py - After scenario evaluation, check market_outlook and apply BUY confidence threshold: BEARISH→90, BULLISH→75, others→settings.CONFIDENCE_THRESHOLD - BUY actions below the adjusted threshold are downgraded to HOLD with a descriptive rationale including the outlook and threshold values - Add 5 integration tests covering bearish suppression, bearish allow, bullish allow, bullish suppression, and neutral default threshold Closes #173 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 08:31:24 +09:00
agentson	c7640a30d7	feat: use playbook allocation_pct in position sizing (#172 ) Some checks failed CI / test (pull_request) Has been cancelled Details - Add playbook_allocation_pct and scenario_confidence parameters to _determine_order_quantity() with playbook-based sizing taking priority over volatility-score fallback when provided - Confidence scaling: confidence/80 multiplier (confidence 96 → 1.2x) clipped to [POSITION_MIN_ALLOCATION_PCT, POSITION_MAX_ALLOCATION_PCT] - Pass matched_scenario.allocation_pct and match.confidence from trading_cycle so AI's allocation decisions reach order execution - Add 4 new tests: playbook priority, confidence scaling, max clamp, and fallback behavior Closes #172 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 08:29:09 +09:00
agentson	60a22d6cd4	feat: add position-aware conditions to StockCondition (#171 ) Some checks failed CI / test (pull_request) Has been cancelled Details - Add unrealized_pnl_pct_above/below and holding_days_above/below fields to StockCondition so AI can generate rules like 'P&L > 3% → SELL' - Evaluate new fields in ScenarioEngine.evaluate_condition() with same AND-combining logic as existing technical indicator fields - Include position fields in _build_match_details() for audit logging - Parse new fields from AI JSON response in PreMarketPlanner._parse_scenario() - Update prompt schema example to show new position-aware condition fields - Add 13 tests covering all new condition combinations and edge cases Closes #171 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 08:27:44 +09:00
agentson	b1f48d859e	feat: include current holdings in pre-market AI prompt (#170 ) Some checks failed CI / test (pull_request) Has been cancelled Details - Add current_holdings parameter to generate_playbook() and _build_prompt() - Inject '## Current Holdings' section into Gemini prompt with qty, entry price, unrealized PnL%, and holding days for each held position - Instruct AI to generate SELL/HOLD scenarios for held stocks even if not in scanner candidates list - Allow held stock codes in _parse_response() valid_codes set so AI- generated SELL scenarios for holdings pass validation - Add 6 tests covering prompt inclusion, omission, and response parsing Closes #170 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 08:25:38 +09:00
jihoson	03f8d220a4	Merge pull request 'fix: use broker balance API as source of truth for SELL qty and holdings (#164 #165 )' (#169 ) from feature/issue-164-165-broker-api-holdings into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #169	2026-02-20 07:52:26 +09:00
agentson	305120f599	fix: use broker balance API as source of truth for SELL qty and holdings (#164 #165 ) Some checks failed CI / test (pull_request) Has been cancelled Details DB의 주문 수량 기록은 실제 체결 수량과 다를 수 있음(부분 체결, 외부 수동 거래). 브로커 잔고 API(output1)를 source of truth로 사용하도록 수정. ## 변경 사항 ### SELL 수량 (#164) - _extract_held_qty_from_balance() 추가 - 국내: output1의 ord_psbl_qty (→ hldg_qty fallback) - 해외: output1의 ovrs_cblc_qty (→ hldg_qty fallback) - _determine_order_quantity()에 broker_held_qty 파라미터 추가 - SELL 시 broker_held_qty 반환 (0이면 주문 스킵) - trading_cycle / run_daily_session 양쪽 호출 지점 수정 - 이미 fetch된 balance_data에서 수량 추출 (추가 API 호출 없음) ### 보유 종목 루프 (#165) - _extract_held_codes_from_balance() 추가 - ord_psbl_qty > 0인 종목 코드 목록 반환 - 실시간 루프에서 스캔 시점에 get_balance() 호출해 보유 종목 병합 - 스캐너 후보 + 실제 보유 종목 union으로 trading_cycle 순회 - 실패 시 경고 로그 후 스캐너 후보만으로 계속 진행 ### 테스트 - TestExtractHeldQtyFromBalance: 7개 (국내/해외/fallback/미보유) - TestExtractHeldCodesFromBalance: 4개 (qty>0 포함, qty=0 제외 등) - TestDetermineOrderQuantity: 5개 (SELL qty, BUY sizing) - test_sell_order_uses_broker_balance_qty_not_db: DB 10주 기록 vs 브로커 5주 확인 → 브로커 값(5) 사용 검증 - 기존 SELL/stop-loss/take-profit 테스트에 output1 mock 추가 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 07:40:45 +09:00
jihoson	faa23b3f1b	Merge pull request 'fix: enforce take_profit_pct in HOLD evaluation loop (#163 )' (#166 ) from feature/issue-163-take-profit-enforcement into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #166	2026-02-20 07:24:14 +09:00
agentson	5844ec5ad3	fix: enforce take_profit_pct in HOLD evaluation loop (#163 ) Some checks failed CI / test (pull_request) Has been cancelled Details HOLD 판정 후 보유 포지션에 대해 stop_loss와 함께 take_profit도 체크하도록 수정. AI가 생성한 take_profit_pct가 실제 거래 로직에 반영되지 않던 구조적 결함 수정. - HOLD 블록에서 loss_pct >= take_profit_threshold 조건 추가 - stop_loss와 상호 배타적으로 동작 (stop_loss 우선 체크) - take_profit 기본값 3.0% (playbook 없는 경우 적용) - 테스트 2개 추가: - test_hold_overridden_to_sell_when_take_profit_triggered - test_hold_not_overridden_when_between_stop_loss_and_take_profit Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 03:00:52 +09:00
jihoson	ff5ff736d8	Merge pull request 'feat: granular Telegram notification filters via .env (#161 )' (#162 ) from feature/issue-161-telegram-notification-filters into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #162	2026-02-20 02:33:56 +09:00
agentson	4a59d7e66d	feat: /notify command for runtime notification filter control (#161 ) Some checks failed CI / test (pull_request) Has been cancelled Details Add /notify Telegram command for adjusting notification filters at runtime without restarting the service: /notify → show current filter state /notify scenario off → disable scenario match alerts /notify market off → disable market open/close alerts /notify all off → disable all (circuit_breaker always on) /notify trades on → re-enable trade execution alerts Changes: - NotificationFilter: add KEYS class var, set_flag(), as_dict() - TelegramClient: add set_notification(), filter_status() - TelegramCommandHandler: add register_command_with_args() + args dispatch - main.py: handle_notify() handler + register /notify command + /help update - Tests: 12 new tests (set_flag, set_notification, register_command_with_args) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 02:33:03 +09:00
agentson	8dd625bfd1	feat: granular Telegram notification filters via .env (#161 ) Some checks failed CI / test (pull_request) Has been cancelled Details Add NotificationFilter dataclass to TelegramClient allowing per-type on/off control via .env variables. circuit_breaker always sends regardless. New .env options (all default true): - TELEGRAM_NOTIFY_TRADES - TELEGRAM_NOTIFY_MARKET_OPEN_CLOSE - TELEGRAM_NOTIFY_FAT_FINGER - TELEGRAM_NOTIFY_SYSTEM_EVENTS - TELEGRAM_NOTIFY_PLAYBOOK - TELEGRAM_NOTIFY_SCENARIO_MATCH (most frequent — set false to reduce noise) - TELEGRAM_NOTIFY_ERRORS Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 02:26:28 +09:00
jihoson	b50977aa76	Merge pull request 'feat: improve dashboard UI with P&L chart and decisions log (#159 )' (#160 ) from feature/issue-159-dashboard-ui-improvement into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #160	2026-02-20 02:20:12 +09:00
agentson	fbcd016e1a	feat: improve dashboard UI with P&L chart and decisions log (#159 ) Some checks failed CI / test (pull_request) Has been cancelled Details - Add /api/pnl/history endpoint to app.py for daily P&L history charting - Rewrite index.html as full SPA with Chart.js bar chart, summary cards, and decisions log table with market filter tabs and 30s auto-refresh - Add test_pnl_history_all_markets and test_pnl_history_market_filter tests Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-20 02:15:34 +09:00
jihoson	ce5773ba45	Merge pull request 'fix: domestic current price fetching and KRX tick unit rounding (#157 )' (#158 ) from feature/issue-157-fix-domestic-price-and-tick into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #158	2026-02-19 16:25:59 +09:00
agentson	7834b89f10	fix: domestic current price fetching and KRX tick unit rounding (#157 ) Some checks failed CI / test (pull_request) Has been cancelled Details Problem 1 — Current price always 0 get_orderbook() used inquire-asking-price-exp-ccn which has no stck_prpr in output1 (only askp/bidp data). This caused every domestic BUY to be skipped with "no affordable quantity (cash=..., price=0.00)". Problem 2 — KRX tick unit error on limit orders Limit order prices were passed unrounded, triggering 호가단위 오류 in VTS. Also ORD_DVSN was wrongly set to "01" (시장가) for limit orders. Fix - Add kr_tick_unit(price) and kr_round_down(price) module-level helpers implementing KRX 7-tier price tick rules (1/5/10/50/100/500/1000원). - Add get_current_price(stock_code) → (price, change_pct, foreigner_net) using FHKST01010100 / inquire-price API (works in VTS, returns correct stck_prpr, prdy_ctrt, frgn_ntby_qty). - Fix send_order() ORD_DVSN: "00"=지정가, "01"=시장가 (was "01"/"06"). - Apply kr_round_down() to limit order price inside send_order(). - Replace both get_orderbook() calls in main.py with get_current_price(). - Update all 4 test_main.py mock sites to use get_current_price AsyncMock. Tests added (25 new tests, all 646 pass) - TestKrTickUnit: 13 parametrized boundary cases + 7 round-down cases - TestGetCurrentPrice: correct fields, correct API path/TR_ID, HTTP error - TestSendOrderTickRounding: tick rounding, ORD_DVSN 00/01 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-19 12:40:55 +09:00
jihoson	e0d6c9f81d	Merge pull request 'fix: correct TR_ID, path, and params for fetch_market_rankings (#155 )' (#156 ) from feature/issue-155-fix-ranking-api into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #156	2026-02-19 11:00:50 +09:00