programgarden 1.37.2__tar.gz → 1.37.4__tar.gz

{programgarden-1.37.2 → programgarden-1.37.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.37.2
+Version: 1.37.4
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -16,7 +16,7 @@ Requires-Dist: croniter (>=6.0.0,<7.0.0)
 Requires-Dist: litellm (>=1.40.0)
 Requires-Dist: lxml (>=6.0.2,<7.0.0)
 Requires-Dist: programgarden-community (>=1.15.3,<2.0.0)
-Requires-Dist: programgarden-core (>=1.28.0,<2.0.0)
+Requires-Dist: programgarden-core (>=1.28.1,<2.0.0)
 Requires-Dist: programgarden-finance (>=1.9.7,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)

programgarden-1.37.4/programgarden/database/fill_reconciler.py

@@ -0,0 +1,271 @@
+"""체결 재조정 — 좁은 확인 창에서 놓친 체결을 뒤늦게 원장에 맞춰 넣는다.
+
+## 왜 필요한가
+
+로트(`workflow_position_lots`)와 체결내역(`trade_history`)은 **체결 이벤트로만** 생긴다
+(`WorkflowPositionTracker._process_fill_internal` 이 유일한 입구). 그런데 주문 접수 직후의
+인라인 확인은 4회 × 2초, 실질 6초밖에 열리지 않는다. 지정가가 몇 분 뒤에 체결되면 그
+사실이 원장에 **영영 도착하지 않았고**, 되찾을 경로가 없었다.
+
+prod 실측(2026-09-14, 공유 전략 b9f837e0): MARA 매수(09-11)·NIO 매도(09-14)가 둘 다 실제로
+체결됐는데 `trade_history` 0건 · 로트 0건이었다. 그래서 `workflow_buy_amount` 가 0 이 되고,
+분모가 0 이라 `workflow_pnl_rate` 가 NULL 로 발행되어 **커뮤니티 수익률이 통째로 비었다.**
+
+## 대칭 — 네 경우를 모두 다룬다
+
+오너 지시(2026-09-14): *"자동매매로 산 게 아닐 수도 맞을 수도 있고, 자동매매로 판 게 아닐
+수도 맞을 수도 있으니깐 대응되어서 사용자에게도 추정치라도 확인되어야지."*
+
+| 매수 | 매도 | 처리 |
+|---|---|---|
+| 자동매매 | 자동매매 | FIFO 실현손익 (정상 경로) |
+| 자동매매 밖 | 자동매매 | 매수 기준이 없다 → 계좌 평균매입가로 **추정** |
+| 자동매매 | 자동매매 밖 | 로트가 남는다 → **유령 포지션**, 밖에서 팔린 것으로 **추정** |
+| 자동매매 밖 | 자동매매 밖 | 전략 성과가 아니다 — off_strategy 로만 집계 |
+
+두 갈래 모두 **추정임을 밝혀서** 기록하고, 확정 실현손익과 섞지 않는다.
+
+## 이 모듈의 경계
+
+브로커를 모른다. 체결 조회는 호출자가 주입한 콜러블로 하고, 계좌 잔고도 인자로 받는다.
+그래서 실행기 생명주기 없이 단위 테스트할 수 있다.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+#: 잔고를 못 읽었을 때 쓰는 표식. **빈 dict 를 쓰면 안 된다** — "보유 0" 과 구분되지 않아
+#: 멀쩡한 로트를 전부 유령으로 보고하고, 실제로 들고 있는 포지션을 밖에서 팔린 것으로
+#: 기록해 버린다. 조회 실패는 반드시 이 값으로 넘겨 재조정을 **건너뛰게** 한다.
+ACCOUNT_UNAVAILABLE: Optional[Dict[str, Any]] = None
+
+#: 유령 판정에 쓰는 수량 허용오차. 소수점 보유(분할매수 등)에서 부동소수 오차로
+#: 0.0000001 주가 "사라진" 것으로 잡히는 것을 막는다.
+_QTY_EPSILON = 1e-6
+
+
+@dataclass
+class ReconcileReport:
+    """한 번의 재조정 결과. 수치는 전부 '무엇을 했는가' 이고 판정이 아니다."""
+
+    checked_orders: int = 0
+    recorded_fills: int = 0
+    still_unfilled: int = 0
+    mismatched_symbol: int = 0
+    phantom_positions: int = 0
+    phantom_quantity: float = 0.0
+    skipped_no_account: bool = False
+    errors: List[str] = field(default_factory=list)
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "checked_orders": self.checked_orders,
+            "recorded_fills": self.recorded_fills,
+            "still_unfilled": self.still_unfilled,
+            "mismatched_symbol": self.mismatched_symbol,
+            "phantom_positions": self.phantom_positions,
+            "phantom_quantity": self.phantom_quantity,
+            "skipped_no_account": self.skipped_no_account,
+            "errors": list(self.errors),
+        }
+
+
+def _normalize(symbol: str) -> str:
+    """종목코드 비교용 정규화 — 표기 차이(공백·대소문자)로 오탐하지 않게."""
+    return str(symbol or "").strip().upper()
+
+
+def _account_avg_price(account_positions: Dict[str, Any], symbol: str) -> Optional[float]:
+    pos = account_positions.get(symbol)
+    if not isinstance(pos, dict):
+        return None
+    raw = pos.get("avg_price")
+    if raw is None:
+        return None
+    try:
+        value = float(raw)
+    except (TypeError, ValueError):
+        return None
+    return value if value > 0 else None
+
+
+def _account_quantities(account_positions: Dict[str, Any]) -> Dict[str, float]:
+    out: Dict[str, float] = {}
+    for symbol, pos in account_positions.items():
+        if not isinstance(pos, dict):
+            continue
+        try:
+            out[symbol] = float(pos.get("quantity") or 0)
+        except (TypeError, ValueError):
+            out[symbol] = 0.0
+    return out
+
+
+async def reconcile_workflow_fills(
+    tracker: Any,
+    *,
+    fetch_fills_by_date: Callable[[str], Awaitable[Dict[str, Dict[str, Any]]]],
+    account_positions: Optional[Dict[str, Any]],
+    min_age_seconds: float = 60.0,
+    limit: int = 50,
+    record_phantom: bool = True,
+) -> ReconcileReport:
+    """미확정 주문을 브로커에 확인해 원장에 넣고, 유령 포지션을 보고한다.
+
+    Args:
+        tracker: ``WorkflowPositionTracker``.
+        fetch_fills_by_date: ``async (order_date) -> {주문번호: {filled_qty, avg_price,
+            fill_time, ...}}``. 조회 실패는 **빈 dict** 를 돌려준다 — 그래서 이 함수는
+            "응답에 없음" 을 "체결 안 됨" 으로 단정하지 않고 미확정으로 남겨 둔다.
+        account_positions: ``{종목코드: {"quantity": float, "avg_price": float}}``.
+            잔고를 못 읽었으면 반드시 ``None``(=``ACCOUNT_UNAVAILABLE``) — 빈 dict 가
+            아니다. ``None`` 이면 유령 갈래를 통째로 건너뛴다.
+        min_age_seconds: 접수 직후 인라인 확인 창과 겹치지 않게 두는 유예.
+        limit: 한 주기에 처리할 최대 주문 수.
+        record_phantom: 유령 포지션을 보고만 할지(False) 여부. 현재는 보고만 한다 —
+            로트 정리는 사용자에게 보이는 수치를 바꾸므로 별도 결정이 필요하다.
+
+    Returns:
+        ``ReconcileReport``. 아무것도 못 했으면 0 이 담긴 보고서이고 예외는 던지지 않는다.
+    """
+    report = ReconcileReport()
+
+    # ── ① 주문 갈래: 우리가 낸 주문인데 체결이 원장에 없는 것 ────────────────
+    try:
+        pending = tracker.get_unconfirmed_workflow_orders(
+            min_age_seconds=min_age_seconds, limit=limit
+        )
+    except Exception as exc:  # 원장 조회 실패는 재조정 전체를 막지 않는다
+        report.errors.append(f"unconfirmed_query_failed: {exc}")
+        pending = []
+
+    report.checked_orders = len(pending)
+
+    # 날짜별로 묶어 브로커 호출을 날짜 수만큼으로 줄인다(앱키당 2초 1회 제한).
+    by_date: Dict[str, List[Dict[str, Any]]] = {}
+    for order in pending:
+        by_date.setdefault(str(order.get("order_date") or ""), []).append(order)
+
+    for order_date, orders in by_date.items():
+        if not order_date:
+            report.errors.append("order_without_date_skipped")
+            continue
+        try:
+            fills = await fetch_fills_by_date(order_date)
+        except Exception as exc:
+            report.errors.append(f"fill_query_failed[{order_date}]: {exc}")
+            continue
+        if not isinstance(fills, dict):
+            report.errors.append(f"fill_query_bad_shape[{order_date}]")
+            continue
+
+        # 주문번호는 앞자리 0 을 떼고 맞춘다 — 브로커 응답과 우리 원장의 표기가 갈린다.
+        normalized = {str(k).lstrip("0") or str(k): v for k, v in fills.items()}
+
+        for order in orders:
+            order_no = str(order.get("order_no") or "")
+            hit = fills.get(order_no) or normalized.get(order_no.lstrip("0") or order_no)
+            if not hit:
+                # 응답에 없다 = 아직 미체결이거나, 조회가 실패했거나, 취소됐다.
+                # 셋을 구분할 수 없으므로 아무것도 기록하지 않고 다음 주기로 넘긴다.
+                report.still_unfilled += 1
+                continue
+            try:
+                filled_qty = float(hit.get("filled_qty") or 0)
+                fill_price = float(hit.get("avg_price") or 0)
+            except (TypeError, ValueError):
+                report.errors.append(f"fill_row_unparsable[{order_no}]")
+                continue
+            if filled_qty <= 0 or fill_price <= 0:
+                report.still_unfilled += 1
+                continue
+
+            symbol = str(order.get("symbol") or hit.get("symbol") or "")
+            side = str(order.get("side") or "")
+            if not symbol or side not in ("buy", "sell"):
+                report.errors.append(f"order_missing_symbol_or_side[{order_no}]")
+                continue
+
+            # 🔴 주문번호만 믿으면 안 된다. 주문번호는 계좌 안에서만 유일하고, 원장에는
+            #    **계좌를 바꾸기 전 주문이 그대로 남아 있다**(workflow_orders 에 계좌 컬럼이
+            #    없다). 새 계좌에서 같은 날 같은 번호가 나오면 남의 체결을 우리 주문으로
+            #    기록하게 된다. 브로커 응답이 종목을 실어 줄 때는 반드시 대조한다.
+            hit_symbol = str(hit.get("symbol") or "").strip()
+            if hit_symbol and _normalize(hit_symbol) != _normalize(symbol):
+                report.mismatched_symbol += 1
+                logger.warning(
+                    "fill_reconcile_symbol_mismatch | order=%s date=%s ledger=%s broker=%s "
+                    "— 같은 주문번호의 다른 종목이라 기록하지 않는다(계좌 교체 흔적일 수 있다)",
+                    order_no, order_date, symbol, hit_symbol,
+                )
+                continue
+
+            # 🔴 매도 잔량 추정의 전제 — 계좌 평균매입가를 반드시 같이 넘긴다.
+            #    없으면 "자동매매가 사지 않은 물량을 팔았다" 가 추정으로 기록되지 않고
+            #    'Sell without enough position' 경고만 남고 조용히 사라진다.
+            avg_price = (
+                _account_avg_price(account_positions, symbol)
+                if isinstance(account_positions, dict) else None
+            )
+
+            try:
+                classification = await tracker.record_fill(
+                    order_no=order_no,
+                    order_date=order_date,
+                    symbol=symbol,
+                    exchange=str(order.get("exchange") or ""),
+                    side=side,
+                    quantity=int(filled_qty),
+                    price=fill_price,
+                    fill_time=str(hit.get("fill_time") or ""),
+                    # 재조정은 우리 주문 원장에서 출발하므로 매체코드를 추측하지 않는다.
+                    # 빈 값이면 트래커가 '우리 주문과 일치하는가' 로만 분류한다.
+                    commda_code="",
+                    account_avg_price=avg_price,
+                )
+            except Exception as exc:
+                report.errors.append(f"record_fill_failed[{order_no}]: {exc}")
+                continue
+
+            report.recorded_fills += 1
+            logger.info(
+                "fill_reconciled | order=%s date=%s %s %s x%s @%s class=%s avg_basis=%s",
+                order_no, order_date, symbol, side, int(filled_qty), fill_price,
+                classification, avg_price,
+            )
+
+    # ── ② 잔고 갈래: 로트는 남았는데 계좌엔 없는 것(밖에서 팔린 것으로 추정) ──
+    if account_positions is None:
+        # 잔고를 못 읽었다. 빈 잔고로 간주하면 보유 중인 로트를 전부 유령으로 보고한다.
+        report.skipped_no_account = True
+        return report
+
+    try:
+        phantoms = tracker.get_phantom_workflow_positions(_account_quantities(account_positions))
+    except Exception as exc:
+        report.errors.append(f"phantom_query_failed: {exc}")
+        return report
+
+    for p in phantoms:
+        missing = float(p.get("missing_quantity") or 0)
+        if missing <= _QTY_EPSILON:
+            continue
+        report.phantom_positions += 1
+        report.phantom_quantity += missing
+        if record_phantom:
+            # 지금은 보고만 한다. 사라진 이유는 밖에서 매도 / 잔고 반영 지연 /
+            # 종목코드 표기 차이 중 어느 것인지 구분할 수 없으므로 **추정**이고,
+            # 로트를 자동으로 지우면 사용자 수치가 근거 없이 바뀐다.
+            logger.warning(
+                "phantom_workflow_position | symbol=%s lot_qty=%s account_qty=%s "
+                "missing=%s avg_buy=%s — 자동매매 밖에서 매도된 것으로 추정됩니다",
+                p.get("symbol"), p.get("lot_quantity"), p.get("account_quantity"),
+                missing, p.get("avg_buy_price"),
+            )
+
+    return report

{programgarden-1.37.2 → programgarden-1.37.4}/programgarden/database/workflow_position_tracker.py

@@ -1484,6 +1484,124 @@ class WorkflowPositionTracker:
             commda_code=commda_code, received_at=received_at, quantity=quantity,
         ) is not None
 
+    # ── 체결 재조정 (2026-09-14) ────────────────────────────────────────────
+    # lot 과 trade_history 는 **체결 이벤트로만** 생긴다(_process_fill_internal 이 유일한
+    # 입구). 주문 접수 직후의 인라인 확인 창은 4회 x 2초로 짧아서, 지정가가 몇 분 뒤에
+    # 체결되면 그 사실이 원장에 영영 도착하지 않는다. 그러면:
+    #   · workflow_position_lots 가 비어 workflow_pnl_rate 가 NULL 로 발행되고
+    #     (분모 0) 커뮤니티 수익률이 통째로 빈다.
+    #   · 실제로 보유 중인 종목을 엔진은 모른다.
+    # prod 실측(2026-09-14): MARA 매수(09-11)·NIO 매도(09-14) 둘 다 실제 체결됐는데
+    # trade_history 0건, lot 0건이었다.
+    #
+    # 아래 두 메서드는 그 복구의 **조회 절반**이다. 실제 브로커 확인과 record_fill 호출은
+    # 호출자(엔진 주기 태스크)가 한다 — 트래커는 브로커를 모른다.
+
+    def get_unconfirmed_workflow_orders(
+        self,
+        *,
+        min_age_seconds: float = 60.0,
+        limit: int = 50,
+        now: Optional[datetime] = None,
+    ) -> List[Dict[str, Any]]:
+        """체결이 원장에 도착하지 않은 우리 주문 목록(오래된 것부터).
+
+        ``workflow_orders`` 에는 있는데 대응하는 ``trade_history`` 행이 없는 주문이다.
+        주문번호는 양쪽에서 앞자리 0 을 떼고 비교한다 — ``normalized_order_no`` 는
+        execution_id 가 있을 때만 채워지므로 그 컬럼만 믿으면 안 된다.
+
+        Args:
+            min_age_seconds: 접수 직후의 인라인 확인 창과 겹치지 않도록 두는 유예.
+                갓 낸 주문을 곧바로 재확인하면 같은 체결이 두 번 기록될 수 있다.
+            limit: 한 번에 가져올 최대 건수(브로커 조회 속도 제한 때문에 필요).
+            now: 테스트용 기준 시각.
+
+        Returns:
+            ``{order_no, order_date, symbol, exchange, side, quantity, price,
+               node_id, job_id, created_at}`` 목록. 체결 여부는 **모른다** —
+            "원장에 없다" 만 말한다. 취소·거부된 주문도 여기 들어오므로, 호출자가
+            브로커에 확인한 뒤에만 원장에 넣어야 한다.
+        """
+        cutoff = ((now or datetime.now()) - timedelta(seconds=max(0.0, min_age_seconds))).isoformat()
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            rows = conn.execute(
+                """
+                SELECT o.order_no, o.order_date, o.symbol, o.exchange, o.side,
+                       o.quantity, o.price, o.node_id, o.job_id, o.created_at
+                  FROM workflow_orders o
+                 WHERE o.product = ? AND o.provider = ? AND o.trading_mode = ?
+                   AND o.created_at < ?
+                   AND NOT EXISTS (
+                         SELECT 1 FROM trade_history t
+                          WHERE t.product = o.product
+                            AND t.provider = o.provider
+                            AND t.trading_mode = o.trading_mode
+                            AND t.order_date = o.order_date
+                            AND COALESCE(NULLIF(ltrim(t.order_no, '0'), ''), t.order_no)
+                                = COALESCE(NULLIF(ltrim(o.order_no, '0'), ''), o.order_no)
+                       )
+                 ORDER BY o.created_at ASC
+                 LIMIT ?
+                """,
+                (self.product, self.provider, self.trading_mode, cutoff, int(limit)),
+            ).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_phantom_workflow_positions(
+        self,
+        account_quantities: Dict[str, float],
+    ) -> List[Dict[str, Any]]:
+        """워크플로우 lot 은 남아 있는데 계좌에는 없는(또는 모자란) 종목.
+
+        🔴 대칭의 나머지 절반이다. 자동매매가 산 종목을 **자동매매 밖에서** 팔면
+        (HTS·전화·다른 API) 그 체결 이벤트를 받아야 lot 이 줄어든다. 못 받으면 lot 이
+        그대로 남아 **계좌에 없는 물량을 보유 중으로 계산**하고 수익률을 과대 계상한다.
+        저장소에 lot↔잔고 대조가 없어서 한번 어긋나면 되맞출 방법이 없었다.
+
+        Args:
+            account_quantities: 브로커 잔고 기준 ``{종목코드: 보유수량}``.
+                **조회에 실패했으면 빈 dict 를 넘기지 마라** — 보유 0 과 구분되지 않아
+                멀쩡한 lot 을 전부 유령으로 보고한다. 호출자가 실패를 걸러야 한다.
+
+        Returns:
+            ``{symbol, lot_quantity, account_quantity, missing_quantity,
+               avg_buy_price}`` 목록. 판정은 하지 않는다 — "차이가 있다" 만 말한다.
+            사라진 이유(밖에서 매도 / 잔고 반영 지연 / 종목코드 표기 차이)는 호출자가
+            **추정**으로 다루고, 사용자에게도 추정임을 밝혀야 한다.
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            rows = conn.execute(
+                """
+                SELECT symbol,
+                       SUM(remaining_qty) AS lot_quantity,
+                       SUM(remaining_qty * buy_price) / NULLIF(SUM(remaining_qty), 0) AS avg_buy_price
+                  FROM workflow_position_lots
+                 WHERE product = ? AND provider = ? AND trading_mode = ?
+                   AND classification = 'workflow' AND remaining_qty > 0
+                 GROUP BY symbol
+                """,
+                (self.product, self.provider, self.trading_mode),
+            ).fetchall()
+
+        normalized = {self._normalize_symbol(k): float(v) for k, v in (account_quantities or {}).items()}
+        phantoms: List[Dict[str, Any]] = []
+        for r in rows:
+            symbol = r["symbol"]
+            lot_qty = float(r["lot_quantity"] or 0)
+            held = normalized.get(self._normalize_symbol(symbol), 0.0)
+            missing = lot_qty - held
+            if missing > 0:
+                phantoms.append({
+                    "symbol": symbol,
+                    "lot_quantity": lot_qty,
+                    "account_quantity": held,
+                    "missing_quantity": missing,
+                    "avg_buy_price": float(r["avg_buy_price"]) if r["avg_buy_price"] is not None else None,
+                })
+        return phantoms
+
     def get_workflow_positions(
         self,
         start_date: Optional[str] = None,

{programgarden-1.37.2 → programgarden-1.37.4}/programgarden/executor.py

@@ -27,6 +27,10 @@ from programgarden_core import (
     ValidationLimits,
     map_reject_code,
     diagnose_missing_order_no,
+    unsupported_market_reject,
+    looks_like_otc_ticker,
+    LS_OVERSEAS_DESK_PHONE,
+    OVERSEAS_STOCK_ORDER_MARKET_CODES,
 )
 from programgarden.context import ExecutionContext, WorkflowEvent
 from programgarden.order_lifecycle import (
@@ -71,6 +75,55 @@ OVERSEAS_STOCK_MARKET_CODES = {
     "83": "81",     # 과거 우리가 쓰던 잘못된 AMEX 코드가 저장된 워크플로우 방어
 }
 
+# 🔴 2026-09-14 미해결 — 여기에 없는 거래소 코드는 `.get(exchange, "82")` 로 **조용히 NASDAQ 이
+#    된다**. prod 실계좌 관측: 보유 종목 ZOMDF(조메디카, 장외)의 잔고 응답 거래소가 `"85"` 로 오는데
+#    그 키가 없어 82 로 떨어졌고, 현재가 조회(g3101)가 82 로 나가 실패 → 매도 주문이 "현재가 조회 실패"
+#    로 끝났다(같은 주기의 NIO/NYSE 는 정상 접수). 종전엔 매도가 현재가 조회를 아예 안 타서 이 구멍이
+#    가려져 있었다(대신 시장가라 00891 로 거부).
+#    🔬 2026-09-14 라이브 실측으로 확정 — **두 값 모두 거부됐다**:
+#       OrdMktCode="82"(NASDAQ) → rsp_cd=03053 "해당 종목번호가 없습니다."
+#       OrdMktCode="81"(NYSE/AMEX) → rsp_cd=03053 "해당 종목번호가 없습니다."
+#       COSAT00301 이 받는 값은 Literal["81","82"] 뿐이므로, **시장 85 의 보유 종목은 이 TR 로는
+#       주문할 수 없다**. 매핑을 어떻게 고쳐도 해결되지 않는다 — 다른 TR 이거나 다른 경로가 필요하다.
+#    남은 일: ① LS 에서 시장 `85` 종목을 매도하는 경로가 무엇인지 확인 — 추측으로 TR/파라미터를
+#    만들지 말 것 ([[feedback_ask_before_inventing_broker_tr_requests]], [[feedback_no_inference_about_ls_broker]])
+#    ② 매핑에 없는 코드는 조용히 82 로 떨어뜨리지 말고, 코드값을 담은 사유와 함께 실패시킬 것
+#    (지금은 "해당 종목번호가 없습니다" 라는 엉뚱한 브로커 메시지로 나타나 원인 파악을 가린다).
+
+
+def resolve_overseas_stock_order_market(
+    exchange: Any, symbol: Any = ""
+) -> "tuple[Optional[str], Optional[str]]":
+    """해외주식 주문용 시장코드 판정. ``(ord_mkt_code, None)`` 또는 ``(None, 사유)``.
+
+    🔴 종전엔 호출부마다 ``STOCK_MARKET_CODES.get(exchange, "82")`` 로 **모르는 코드를
+    조용히 나스닥으로 바꿔** 보냈다. 그러면 브로커가 `03053 "해당 종목번호가 없습니다"` 로
+    답하고, 사용자에게는 **종목 코드를 잘못 쓴 것처럼** 보인다 — 실제로는 그 종목이 이
+    API 로 거래할 수 없는 시장(장외/OTC 등)에 있다는 뜻이다(2026-09-14 실계좌 관측 +
+    LS증권 유선 확인: OTC 종목은 API 주문 불가, 전화 주문만 가능).
+
+    그래서 매핑에 없으면 **요청을 보내지 않고** 실패시킨다. 보내 봐야 성공할 수 없고,
+    LS 주문 속도 제한(초당 1건)만 쓴다.
+    """
+    if exchange is None:
+        return (None, "거래소가 비어 있습니다.")
+    key = str(exchange).strip()
+    code = OVERSEAS_STOCK_ORDER_MARKET_CODES.get(key) or OVERSEAS_STOCK_ORDER_MARKET_CODES.get(key.upper())
+    if code:
+        return (code, None)
+    # LS 경험칙: 5자 티커가 F 로 끝나면 보통 OTC 로 넘어간 종목이다. LS 도 "항상 맞는
+    # 룰은 아니다" 라고 단서를 달았으므로 **차단 판단에는 쓰지 않고**(차단은 거래소 코드로
+    # 한다) 안내 문구를 구체적으로 만드는 데만 쓴다.
+    otc_hint = "티커가 5자이고 F 로 끝나 장외로 넘어간 종목으로 보입니다. " if looks_like_otc_ticker(symbol) else ""
+    return (
+        None,
+        f"이 종목이 속한 시장({key})은 자동매매가 주문할 수 없습니다. "
+        f"해외주식 주문은 뉴욕·아멕스·나스닥만 지원합니다. {otc_hint}"
+        "장외(OTC) 종목이 이 경우이며, 자동매매로는 매도할 수 없습니다. "
+        f"LS증권 해외주식 데스크({LS_OVERSEAS_DESK_PHONE})로 전화해 매도를 요청하세요 — "
+        "미국 정규장 시간에 현지 브로커를 찾아 매도해 줍니다.",
+    )
+
 
 def _qty_num(value: Any, default: int = 0):
     """수량 필드 정규화 — 정수 값이면 int, 소수점(fractional)이면 값 보존 float.
@@ -15523,7 +15576,7 @@ class NewOrderNodeExecutor(NodeExecutorBase):
             #    을 낸 정상 무신호 날이 매 실행 노드 FAILED + 사용자 알림으로 승격된다
             #    (D2, 벤치 2026-09-06 이 없애려던 바로 그 증상). 그래서 분류를 먼저
             #    돌리고, **확실한 배선 고장**(`hard`)일 때만 NO_SYMBOL 로 승격한다.
-            unfilled = self._describe_unfilled_order_fields(order, context, node_type)
+            unfilled = self._describe_unfilled_order_fields(order, context, node_type, node_id)
             reason, detail = self._diagnose_empty_reason(
                 order, config, raw_order_expr, context, node_id=node_id
             )
@@ -15912,6 +15965,7 @@ class NewOrderNodeExecutor(NodeExecutorBase):
         order: Any,
         context: Optional["ExecutionContext"] = None,
         node_type: str = "",
+        node_id: Optional[str] = None,
     ) -> Optional[Dict[str, Any]]:
         """주문 입력이 **채워지지 않아서** 주문을 못 만든 경우의 구체 사유.
 
@@ -15990,9 +16044,42 @@ class NewOrderNodeExecutor(NodeExecutorBase):
         #    수량이 0/음수인 것만으로는 승격하지 않는다 — 자금 부족·소수점 잔량 등
         #    **정상적으로 오늘 못 사는 날**이 있고, 그건 `_diagnose_empty_reason` 이
         #    no_signal / fractional_only 로 더 정확히 분류한다.
-        hard = item_shape is not None or any(
-            kind in ("unresolved_template", "invalid") for kind in kinds.values()
-        )
+        # 🔴 2026-09-14 prod 실관측(엔진 1.37.2 첫 판단) — 거짓 경보 교정.
+        #    매수 노드가 `{{ item.symbol }}` 을 쓰는데 상류(SymbolFilter)가 **정상적으로**
+        #    빈 목록을 냈다(관심종목을 이미 보유 → 오늘 살 것 없음). 반복이 아예 일어나지
+        #    않아 템플릿이 리터럴로 남았는데, 그걸 `unresolved_template` = 배선 고장으로
+        #    승격해 **매 실행 노드 FAILED + 사용자 알림**이 됐다. "오늘 살 게 없다" 는
+        #    정상이다.
+        #    → 반복 중이 아닐 때 남은 **아이템 바인딩**(`{{ item… }}` / `{{ index }}`)은
+        #      승격하지 않고 `_diagnose_empty_reason` 에 넘긴다. 그쪽은 상류 리스트 포트로
+        #      "상류가 비어 반복이 안 됨(no_signal)" 과 "배열 소스 없이 item 을 씀(unbound)"
+        #      을 이미 가른다 — 이 함수의 계약대로 분류는 그쪽 몫이다.
+        #      반복 **중인데도** 안 풀린 템플릿은 종전대로 고장이다(항목이 있는데 못 읽었다).
+        def _is_item_binding(value: Any) -> bool:
+            if not isinstance(value, str):
+                return False
+            return bool(re.search(r"\{\{\s*(item|index|total)\b", value))
+
+        #    판정 축은 "반복 중인가" 가 아니라 **상류 배열이 있는데 비었는가** 다.
+        #      · 상류 리스트 포트가 있고 비었다  → 오늘 줄 게 없어 반복이 안 된 것(정상)
+        #      · 리스트 포트가 아예 없다         → 배열 소스 없이 item 을 쓴 배선 고장
+        #    `_upstream_array_is_empty` 가 이미 그 셋(True/False/None)을 가른다.
+        upstream_empty = False
+        if not iterating and context is not None and node_id:
+            try:
+                upstream_empty = _upstream_array_is_empty(_input_namespace(context, node_id)) is True
+            except Exception:  # noqa: BLE001 — 진단이 실행을 막지 않는다
+                upstream_empty = False
+        hard_kinds = {
+            key
+            for key, kind in kinds.items()
+            if kind == "invalid"
+            or (
+                kind == "unresolved_template"
+                and not (upstream_empty and _is_item_binding(order.get(key)))
+            )
+        }
+        hard = item_shape is not None or bool(hard_kinds)
 
         labels = NewOrderNodeExecutor._ORDER_FIELD_LABELS
         kind_ko = {
@@ -16297,10 +16384,32 @@ class NewOrderNodeExecutor(NodeExecutorBase):
             context.log("warning", "주문 타입 자동 변환: 해외주식 매수는 시장가 불가 → 현재가 기준 지정가 주문으로 전환", node_id)
             ordprc_ptn_code = "00"
 
-        ord_mkt_code = self.STOCK_MARKET_CODES.get(exchange, "82")
+        # 🔴 브로커를 부르기 전에 시장을 판정한다 — 모르는 코드를 나스닥으로 바꿔 보내면
+        #    03053 "해당 종목번호가 없습니다" 로 돌아와 종목 탓처럼 보인다(2026-09-14).
+        ord_mkt_code, market_error = resolve_overseas_stock_order_market(exchange, symbol)
+        if market_error:
+            reject = unsupported_market_reject(exchange, symbol)
+            logger.warning(
+                "order_unsupported_market | node=%s symbol=%s exchange=%r — %s",
+                node_id, symbol, exchange, market_error,
+            )
+            context.log("error", f"{symbol}: {market_error}", node_id)
+            await self._notify_order_reject(context, node_id, symbol, reject)
+            return self._order_result(
+                False, symbol, exchange, side, qty, price,
+                market_error, reject_info=reject,
+            )
 
-        # 매수 지정가 주문인데 가격이 없으면 현재가 조회
-        if is_buy and ordprc_ptn_code == "00" and price <= 0:
+        # 지정가 주문인데 가격이 없으면 현재가 조회.
+        # 🔴 2026-09-14 — 종전엔 **매수만** 이 경로를 탔다. 그래서 매도를 지정가로 두고 가격을
+        #    비우면 price=0 이 그대로 나가 거부됐다. 미국주식 **주간거래(Blue Ocean) 세션은
+        #    지정가만 받는다**(rsp_cd 00891 "주간거래는 지정가로만 주문이 가능합니다", 실계좌
+        #    관측) — 그 시간대에 손절·익절을 쓰려면 매도도 지정가여야 하는데, 사람이 종목마다
+        #    가격을 적을 수는 없다(손절 대상은 조건이 고른다). 매수와 같은 규칙으로 맞춘다.
+        #    ⚠️ 지정가는 **체결을 보장하지 않는다** — 손절인데 안 팔릴 수 있다. 그건 워크플로우가
+        #       지정가를 선택한 결과이고, 노드 설정에 그대로 드러난다(엔진이 몰래 유형을 바꾸지
+        #       않는다 — 오너 지시 2026-09-14: "다시 보낼 때는 노드로 워크플로우에 있어야 사용자가 안다").
+        if ordprc_ptn_code == "00" and price <= 0:
             try:
                 current_price = await self._get_current_price(ls, symbol, ord_mkt_code, context, node_id)
                 if current_price and current_price > 0:
@@ -16334,6 +16443,14 @@ class NewOrderNodeExecutor(NodeExecutorBase):
 
             # 디버그: 응답 전체 출력
             context.log("debug", f"COSAT00301 response: rsp_cd={response.rsp_cd}, rsp_msg={response.rsp_msg}", node_id)
+            # 🔴 2026-09-14 — `context.log` 는 리스너 통지 전용이라 **stdout 에 안 나온다**.
+            #    그래서 파드 로그만 보면 접수됐는지 거부됐는지 구분이 안 됐다(주문 결과 0줄).
+            #    증권사 응답 코드는 사고 조사의 1차 근거라 모듈 로거로도 남긴다
+            #    (`kubectl logs | grep broker_order_response`).
+            logger.info(
+                "broker_order_response | node=%s tr=COSAT00301 symbol=%s rsp_cd=%s rsp_msg=%s",
+                node_id, symbol, response.rsp_cd, response.rsp_msg,
+            )
 
             if response.error_msg:
                 reject = map_reject_code(
@@ -16344,6 +16461,10 @@ class NewOrderNodeExecutor(NodeExecutorBase):
                     f"Order failed: {symbol} - {response.error_msg} ({reject.cause})",
                     node_id,
                 )
+                logger.warning(
+                    "broker_order_rejected | node=%s symbol=%s rsp_cd=%s cause=%s msg=%s",
+                    node_id, symbol, getattr(response, "rsp_cd", None), reject.cause, response.error_msg,
+                )
                 await self._notify_order_reject(context, node_id, symbol, reject)
                 return self._order_result(
                     False, symbol, exchange, side, qty, price,
@@ -16373,6 +16494,10 @@ class NewOrderNodeExecutor(NodeExecutorBase):
                 )
 
             context.log("info", f"Order submitted: {symbol} {side} {qty}@{price} → order_id={order_no}", node_id)
+            logger.info(
+                "broker_order_submitted | node=%s symbol=%s side=%s qty=%s price=%s order_id=%s",
+                node_id, symbol, side, qty, price, order_no,
+            )
 
             # Record workflow order for FIFO tracking (OrderNo가 있는 경우만)
             context.record_workflow_order(
@@ -16792,6 +16917,75 @@ class NewOrderNodeExecutor(NodeExecutorBase):
             context.log("debug", f"COSAQ00102 fill query exception: {e}", node_id)
             return 0, 0.0
 
+    async def _query_overseas_stock_fills_by_date(
+        self,
+        ls,
+        order_date: str,
+        context: ExecutionContext,
+        node_id: str,
+    ) -> Dict[str, Dict[str, Any]]:
+        """그 날짜의 **모든** 체결을 주문번호별로 모아 돌려준다 (COSAQ00102).
+
+        ``_query_overseas_stock_fill`` 과 같은 TR 을 부르지만 주문 하나로 좁히지 않는다.
+        그 함수는 이미 ``IsuNo=""`` · ``SrtOrdNo=999999999`` 로 **그날 전체**를 받아 온 뒤
+        주문번호로 거르고 있어서, 미확정 주문이 N 건이면 같은 응답을 N 번 받게 된다.
+        LS 주문체결내역 조회는 앱키당 2초에 1회이고 같은 앱키를 SDK 계좌 추적기가 60초
+        주기로 이미 쓴다 — 재조정이 건당 호출하면 그 예산을 그대로 먹는다. 날짜당 1회로
+        묶으면 미확정이 몇 건이든 호출 수는 날짜 수만큼이다.
+
+        Returns:
+            ``{주문번호: {"filled_qty", "avg_price", "symbol", "fill_time"}}``.
+            조회 실패·응답 없음은 **빈 dict** 다 — "체결 0건" 과 구분되지 않으므로
+            호출자는 이 결과만으로 "체결 안 됐다" 고 단정하면 안 된다.
+        """
+        out: Dict[str, Dict[str, Any]] = {}
+        try:
+            from programgarden_finance import COSAQ00102
+
+            response = ls.overseas_stock().accno().cosaq00102(
+                body=COSAQ00102.COSAQ00102InBlock1(
+                    RecCnt=1, QryTpCode="1", BkseqTpCode="1", OrdMktCode="00",
+                    BnsTpCode="0", IsuNo="", SrtOrdNo=999999999, OrdDt=order_date,
+                    ExecYn="1", CrcyCode="000", ThdayBnsAppYn="0", LoanBalHldYn="0",
+                ),
+            )
+            result = await response.req_async()
+            if not result or not getattr(result, "block3", None):
+                return out
+
+            for item in result.block3:
+                order_no = str(getattr(item, "OrdNo", "") or "").strip()
+                if not order_no:
+                    continue
+                q = _qty_num(getattr(item, "ExecQty", 0) or 0)
+                if q <= 0:
+                    continue
+                p = float(getattr(item, "OvrsExecPrc", 0) or getattr(item, "OvrsOrdPrc", 0) or 0)
+                row = out.setdefault(order_no, {
+                    "filled_qty": 0, "_amount": 0.0, "symbol": "", "fill_time": "",
+                })
+                row["filled_qty"] += q
+                row["_amount"] += q * p
+                # 🔴 LS 는 TR 마다 같은 뜻의 필드 이름이 다르고, 이 블록에는 `ShtnIsuNo`
+                #    (단축종목번호)와 `IsuNo`(종목번호)가 **둘 다** 있다. 이 저장소의 관행은
+                #    ShtnIsuNo 우선·IsuNo 폴백이다(잔고·체결 파싱이 전부 그렇게 한다).
+                #    이름을 틀리면 getattr 기본값 때문에 **예외 없이 빈 값**이 되고, 재조정의
+                #    종목 대조 가드가 조용히 무력화된다(계좌 교체 후 주문번호가 겹칠 때 남의
+                #    체결을 기록하게 됨). 필드명 계약은 test_cosaq00102_field_contract.py 가 잠근다.
+                #    거래소는 싣지 않는다 — 우리 주문 원장의 exchange 가 권위 있는 값이다.
+                row["symbol"] = row["symbol"] or str(
+                    getattr(item, "ShtnIsuNo", "") or getattr(item, "IsuNo", "") or ""
+                ).strip()
+                row["fill_time"] = row["fill_time"] or str(getattr(item, "ExecTime", "") or "").strip()
+
+            for row in out.values():
+                qty = row["filled_qty"]
+                row["avg_price"] = (row.pop("_amount") / qty) if qty > 0 else 0.0
+            return out
+        except Exception as e:
+            context.log("debug", f"COSAQ00102 batch fill query exception: {e}", node_id)
+            return {}
+
     async def _query_overseas_futures_fill(
         self,
         ls,
@@ -17821,9 +18015,16 @@ class ModifyOrderNodeExecutor(NodeExecutorBase):
             context.log("error", f"Modify order blocked: {resolve_error}", node_id)
             return self._error_result(resolve_error)
 
-        # 시장 코드 결정
-        ord_mkt_code = self.STOCK_MARKET_CODES.get(exchange, "82")
-        
+        # 시장 코드 결정 — 지원 밖이면 요청을 보내지 않는다(신규주문과 같은 규칙).
+        ord_mkt_code, market_error = resolve_overseas_stock_order_market(exchange, symbol)
+        if market_error:
+            logger.warning(
+                "modify_unsupported_market | node=%s symbol=%s exchange=%r — %s",
+                node_id, symbol, exchange, market_error,
+            )
+            context.log("error", f"{symbol}: {market_error}", node_id)
+            return self._error_result(market_error)
+
         # 호가유형코드 (지정가)
         ordprc_ptn_code = config.get("price_type_code", "00")
         
@@ -18395,8 +18596,27 @@ class CancelOrderNodeExecutor(NodeExecutorBase):
         from programgarden_finance.ls.overseas_stock.order.COSAT00301.blocks import COSAT00301InBlock1
 
 
-        # 시장 코드 결정
-        ord_mkt_code = self.STOCK_MARKET_CODES.get(exchange, "82")
+        # 시장 코드 결정 — 지원 밖이면 요청을 보내지 않는다(신규·정정과 같은 규칙).
+        # 애초에 주문이 나갈 수 없는 시장이라 취소할 원주문도 없지만, 조용히 나스닥으로
+        # 바꿔 보내면 **다른 시장의 같은 번호** 를 취소하려 드는 셈이라 더 위험하다.
+        ord_mkt_code, market_error = resolve_overseas_stock_order_market(exchange, symbol)
+        if market_error:
+            logger.warning(
+                "cancel_unsupported_market | node=%s symbol=%s exchange=%r — %s",
+                node_id, symbol, exchange, market_error,
+            )
+            context.log("error", f"{symbol}: {market_error}", node_id)
+            return {
+                "cancel_result": {
+                    "success": False,
+                    "error": market_error,
+                    "order_id": order_id,
+                    "product": "overseas_stock",
+                    "reject_info": unsupported_market_reject(exchange, symbol).model_dump(),
+                },
+                "cancelled_order_id": "",
+                "cancelled_order": None,
+            }
 
         try:
             order_api = ls.overseas_stock().주문().cosat00301(
@@ -21072,6 +21292,7 @@ class WorkflowJob:
         # Checkpoint support
         self._checkpoint_mgr = None  # CheckpointManager (lazy init)
         self._checkpoint_task: Optional[asyncio.Task] = None  # 실시간 주기 저장 태스크
+        self._reconcile_task: Optional[asyncio.Task] = None  # 체결 재조정 주기 태스크
         self._completed_node_ids: Set[str] = set()  # 완료된 노드 ID 집합
 
         # Per-node diagnostic cache for get_state() (in-memory only, not persisted to checkpoint)
@@ -21321,6 +21542,7 @@ class WorkflowJob:
                 )
                 # 실시간 checkpoint 주기 저장 시작
                 self._start_checkpoint_loop()
+                self._start_reconcile_loop()
                 await self._event_loop()
             elif has_event_sources and self.context.is_dry_run:
                 logger.info(
@@ -21348,6 +21570,7 @@ class WorkflowJob:
             # 정상 완료 → checkpoint 삭제
             self._delete_checkpoint()
             await self._stop_checkpoint_loop()
+            await self._stop_reconcile_loop()
 
             # 🆕 Job 완료 알림
             await self.context.notify_job_state(self.status, self.stats)
@@ -23723,6 +23946,7 @@ class WorkflowJob:
         # Checkpoint 저장 (cleanup 전에)
         await self._save_checkpoint()
         await self._stop_checkpoint_loop()
+        await self._stop_reconcile_loop()
 
         self.context.stop()
 
@@ -24237,6 +24461,111 @@ class WorkflowJob:
         except asyncio.CancelledError:
             pass
 
+    # ── 체결 재조정 주기 태스크 (2026-09-14) ────────────────────────────────
+    #: 재조정 주기. 계좌 추적기가 60초마다 같은 앱키를 쓰므로 그보다 넉넉히 둔다.
+    #: LS 주문체결내역 조회는 앱키당 2초 1회이고, 재조정은 **날짜당 1회**만 부른다.
+    RECONCILE_INTERVAL_SEC = 180.0
+    #: 접수 직후 인라인 확인 창(4회 x 2초)과 겹치지 않게 두는 유예.
+    RECONCILE_MIN_ORDER_AGE_SEC = 60.0
+
+    def _find_account_tracker_entry(self) -> Optional[Dict[str, Any]]:
+        """재조정에 쓸 해외주식 계좌 추적기 엔트리(있으면).
+
+        추적기는 이미 60초 주기로 잔고를 들고 있다 — 유령 포지션 대조에 쓸 보유수량과
+        매도 추정에 쓸 평균매입가를 **추가 브로커 호출 없이** 여기서 얻는다.
+        """
+        for entry in self._active_trackers.values():
+            if not isinstance(entry, dict):
+                continue
+            if entry.get("type") != "account_tracker":
+                continue
+            if entry.get("tracker") is not None and entry.get("ls") is not None:
+                return entry
+        return None
+
+    @staticmethod
+    def _account_positions_snapshot(acct_tracker: Any) -> Optional[Dict[str, Any]]:
+        """계좌 추적기 캐시 → ``{종목: {quantity, avg_price}}``.
+
+        🔴 캐시를 아직 못 채웠으면 **None** 을 돌려준다(빈 dict 아님). 빈 dict 는 "보유 0"
+        과 구분되지 않아, 실제로 들고 있는 포지션을 전부 "자동매매 밖에서 팔렸다" 로
+        기록하게 만든다.
+        """
+        positions = getattr(acct_tracker, "_positions", None)
+        if not isinstance(positions, dict) or not positions:
+            return None
+        out: Dict[str, Any] = {}
+        for symbol, pos in positions.items():
+            try:
+                qty = float(getattr(pos, "quantity", 0) or 0)
+            except (TypeError, ValueError):
+                qty = 0.0
+            avg = getattr(pos, "buy_price", None)
+            try:
+                avg = float(avg) if avg is not None else None
+            except (TypeError, ValueError):
+                avg = None
+            out[str(symbol)] = {"quantity": qty, "avg_price": avg}
+        return out
+
+    async def _reconcile_fills_once(self) -> Optional[Dict[str, Any]]:
+        """한 주기 재조정. 준비가 안 됐으면 조용히 건너뛴다(None)."""
+        from .database.fill_reconciler import reconcile_workflow_fills
+
+        tracker = getattr(self.context, "_workflow_position_tracker", None)
+        if tracker is None:
+            return None
+        entry = self._find_account_tracker_entry()
+        if entry is None:
+            return None
+
+        ls = entry["ls"]
+        node_id = "fill_reconciler"
+
+        async def _fetch(order_date: str) -> Dict[str, Dict[str, Any]]:
+            return await self._query_overseas_stock_fills_by_date(
+                ls, order_date, self.context, node_id
+            )
+
+        report = await reconcile_workflow_fills(
+            tracker,
+            fetch_fills_by_date=_fetch,
+            account_positions=self._account_positions_snapshot(entry["tracker"]),
+            min_age_seconds=self.RECONCILE_MIN_ORDER_AGE_SEC,
+        )
+        if report.recorded_fills or report.phantom_positions or report.errors:
+            logger.info("fill_reconcile | %s", report.as_dict())
+        return report.as_dict()
+
+    async def _reconcile_loop(self) -> None:
+        """주기 재조정. 한 주기의 실패가 루프를 죽이지 않는다."""
+        try:
+            while True:
+                await asyncio.sleep(self.RECONCILE_INTERVAL_SEC)
+                try:
+                    await self._reconcile_fills_once()
+                except Exception as e:
+                    logger.warning("fill_reconcile_cycle_failed: %s", e)
+        except asyncio.CancelledError:
+            pass
+
+    def _start_reconcile_loop(self) -> None:
+        """체결 재조정 주기 실행 시작."""
+        if self._reconcile_task is not None:
+            return
+        self._reconcile_task = asyncio.ensure_future(self._reconcile_loop())
+        logger.debug("Fill reconcile loop 시작 (%s초 주기)", self.RECONCILE_INTERVAL_SEC)
+
+    async def _stop_reconcile_loop(self) -> None:
+        """체결 재조정 중단."""
+        if self._reconcile_task and not self._reconcile_task.done():
+            self._reconcile_task.cancel()
+            try:
+                await self._reconcile_task
+            except asyncio.CancelledError:
+                pass
+        self._reconcile_task = None
+
     def _start_checkpoint_loop(self) -> None:
         """실시간 워크플로우에서 checkpoint 주기 저장 시작."""
         if self._checkpoint_task is not None:

{programgarden-1.37.2 → programgarden-1.37.4}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.37.2"
+version = "1.37.4"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -36,7 +36,7 @@ litellm = ">=1.40.0"
 # 로 통째 실패한다(1.35.1 의 조용한 TypeError 보다 강한 모듈 로드 실패).
 # (1.26.0 이후로도 context.py 는 WorkflowPnLEvent(**event_data) 에 personal_metrics
 #  를 무조건 실으므로 그 하한 근거도 이 상한에 포함된다.)
-programgarden-core = "^1.28.0"
+programgarden-core = "^1.28.1"
 programgarden-finance = "^1.9.7"
 programgarden-community = "^1.15.3"