programgarden 1.29.2__tar.gz → 1.29.4__tar.gz

{programgarden-1.29.2 → programgarden-1.29.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.29.2
+Version: 1.29.4
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산

{programgarden-1.29.2 → programgarden-1.29.4}/programgarden/__init__.py

@@ -91,7 +91,7 @@ except ImportError:
     # Community package not installed
     pass
 
-__version__ = "1.29.0"
+__version__ = "1.29.3"
 __all__ = [
     # Core
     "ProgramGarden",

{programgarden-1.29.2 → programgarden-1.29.4}/programgarden/executor.py

@@ -15,6 +15,7 @@ import ast
 import re
 import uuid
 import logging
+import sys
 
 from programgarden.resolver import WorkflowResolver, ResolvedWorkflow, ValidationResult
 from programgarden_core import (
@@ -42,6 +43,44 @@ from programgarden_core.nodes.base import BaseMessagingNode
 logger = logging.getLogger("programgarden.executor")
 
 
+def _safe_print(*args: Any, **kwargs: Any) -> None:
+    """Emit console output without ever letting it abort the caller.
+
+    Console output is a side effect — a workflow must never die because a log
+    line could not be rendered. On a console whose encoding cannot represent
+    the text (cp949 on Korean Windows is the case we hit), a bare ``print``
+    raises ``UnicodeEncodeError``. Two things make that fatal rather than
+    cosmetic:
+
+    1. The progress line at the head of ``_execute_main_flow`` runs before any
+       node does, so the whole job dies before it starts.
+    2. The same call pattern sits inside ``except`` blocks, so the *reporting*
+       path raises too and the original cause is swallowed — the failure never
+       reaches ``notify_job_state`` and vanishes silently.
+
+    Note that ASCII-only literals are not sufficient protection: interpolated
+    values (node names, exception messages) can themselves carry characters the
+    console cannot encode. So every print in this module goes through here.
+    """
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        # Re-render through the stream's own encoding so the line still lands,
+        # with unrepresentable characters replaced rather than the job lost.
+        try:
+            stream = kwargs.get("file") or sys.stdout
+            encoding = getattr(stream, "encoding", None) or "ascii"
+            sep = kwargs.get("sep", " ")
+            end = kwargs.get("end", "\n")
+            text = sep.join(str(a) for a in args) + end
+            stream.write(text.encode(encoding, errors="replace").decode(encoding, errors="replace"))
+        except Exception:
+            logger.debug("console output dropped", exc_info=True)
+    except Exception:
+        # Logging is never load-bearing.
+        logger.debug("console output dropped", exc_info=True)
+
+
 # lib reserved iteration variable roots — valid ONLY mid-iteration.
 # `{{ item.* }}` (auto-iterate per-item) and `{{ row.* }}` (ConditionNode
 # items.extract) only resolve while the executor has an iteration context set;
@@ -77,6 +116,95 @@ REALTIME_NODE_TYPES: frozenset = frozenset({
 })
 
 
+def _order_failure_from_outputs(outputs: Any) -> Optional[str]:
+    """Return a human-readable reason if an order node *failed without raising*.
+
+    Order nodes never raise on failure — they return ``order_result.success=False``
+    with an :class:`EmptyOrderReason`. A node that returns normally is reported as
+    COMPLETED with ``errors_count=0`` and ``last_error=None``, so "the order never
+    went out" leaves **no trace on any observable surface**: the dashboard, the
+    monitoring page and the user all see a clean run. In automated trading that is
+    the single most dangerous failure mode.
+
+    ``no_signal`` ("no trading signal today") is a legitimate no-op and is NOT a
+    failure. Every other reason (``fetch_failed``, ``no_symbol``, or an explicit
+    ``error`` with no reason at all) means an order was supposed to go out and
+    didn't — surface it.
+
+    Returns None when there is nothing wrong.
+    """
+    if not isinstance(outputs, dict):
+        return None
+    result = outputs.get("order_result")
+    if not isinstance(result, dict) or result.get("success") is not False:
+        return None
+
+    reason = result.get("reason")
+    if reason == EmptyOrderReason.NO_SIGNAL.value:
+        return None
+
+    parts = [
+        str(p) for p in (result.get("message"), result.get("detail"), result.get("error"))
+        if p
+    ]
+    label = reason or "order_failed"
+    return f"{label}: {' — '.join(parts)}" if parts else str(label)
+
+
+def _orders_placed_from_outputs(outputs: Any) -> int:
+    """Return how many orders this node successfully *submitted* (accepted).
+
+    DEF-26: the job's ``orders_placed`` stat was initialised to 0 and never
+    incremented, so the dashboard/monitoring always reported "0 orders placed"
+    even after a real fill. This derives the submitted count from the node's
+    ``order_result``:
+
+    - single-order shape (``_order_result``): 1 when ``success is True`` (an
+      order number came back = accepted), else 0.
+    - batch shape (``success_count``): that count (defensive — currently unused
+      by the live single-order path).
+    - non-order nodes / failed orders / no_signal: 0.
+
+    "Submitted" means accepted by the broker (order number returned), NOT
+    filled — see :func:`_orders_filled_from_outputs` for fills (DEF-27).
+    """
+    if not isinstance(outputs, dict):
+        return 0
+    result = outputs.get("order_result")
+    if not isinstance(result, dict):
+        return 0
+    if "success_count" in result:
+        try:
+            return max(0, int(result.get("success_count") or 0))
+        except (TypeError, ValueError):
+            return 0
+    return 1 if result.get("success") is True else 0
+
+
+def _orders_filled_from_outputs(outputs: Any) -> int:
+    """Return how many orders this node confirmed as *fully filled*.
+
+    DEF-26/DEF-27: ``orders_filled`` was a dead counter, and the engine
+    reported a bare "submitted" (order accepted) as if the order had traded.
+    An order only counts here when a post-submission re-query confirmed a
+    complete fill (``order_result.status == "filled"``, set by
+    :meth:`NewOrderNodeExecutor._confirm_order_fill`). ``submitted`` / ``open``
+    / ``partially_filled`` deliberately do NOT count — an accepted-but-unfilled
+    order must never inflate the fill counter.
+    """
+    if not isinstance(outputs, dict):
+        return 0
+    result = outputs.get("order_result")
+    if not isinstance(result, dict):
+        return 0
+    if "filled_count" in result:
+        try:
+            return max(0, int(result.get("filled_count") or 0))
+        except (TypeError, ValueError):
+            return 0
+    return 1 if (result.get("status") == "filled" and result.get("success") is True) else 0
+
+
 def _free_root_names(text: str) -> Set[str]:
     """Return the set of free-variable root identifiers referenced (ctx=Load) by
     every ``{{ ... }}`` expression embedded in ``text``.
@@ -8307,8 +8435,8 @@ class DisplayNodeExecutor(NodeExecutorBase):
         
         if chart_type == "summary":
             # Raw JSON 표시
-            print(f"\n📋 {title or 'Data Summary'} [{now}]")
-            print("=" * 60)
+            _safe_print(f"\n📋 {title or 'Data Summary'} [{now}]")
+            _safe_print("=" * 60)
             try:
                 def serialize(obj):
                     if hasattr(obj, 'model_dump'):
@@ -8322,11 +8450,11 @@ class DisplayNodeExecutor(NodeExecutorBase):
                     return obj
                 
                 serialized = serialize(data)
-                print(json.dumps(serialized, indent=2, ensure_ascii=False, default=str))
+                _safe_print(json.dumps(serialized, indent=2, ensure_ascii=False, default=str))
             except Exception as e:
-                print(f"(직렬화 실패: {e})")
-                print(str(data)[:500])
-            print("=" * 60 + "\n")
+                _safe_print(f"(직렬화 실패: {e})")
+                _safe_print(str(data)[:500])
+            _safe_print("=" * 60 + "\n")
             
             output_data["data"] = data
             
@@ -8337,8 +8465,8 @@ class DisplayNodeExecutor(NodeExecutorBase):
             sort_by = config.get("sort_by")
             sort_order = config.get("sort_order", "desc")
             
-            print(f"\n📊 {title or 'Table'} [{now}]")
-            print("=" * 80)
+            _safe_print(f"\n📊 {title or 'Table'} [{now}]")
+            _safe_print("=" * 80)
             
             # 데이터 형식 판단
             if isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict):
@@ -8352,13 +8480,13 @@ class DisplayNodeExecutor(NodeExecutorBase):
                     (k, k) for k in list(rows[0].keys())[:8]
                 ]
                 header = " | ".join(f"{label:<12}" for _, label in cols)
-                print(header)
-                print("-" * 80)
+                _safe_print(header)
+                _safe_print("-" * 80)
                 for row in rows:
                     values = " | ".join(
                         f"{self._format_value(row.get(key)):<12}" for key, _ in cols
                     )
-                    print(values)
+                    _safe_print(values)
                     
             elif isinstance(data, dict):
                 # dict of dicts (symbol: {field: value}) 또는 flat dict
@@ -8374,19 +8502,19 @@ class DisplayNodeExecutor(NodeExecutorBase):
                             (k, k) for k in list(items[0][1].keys())[:6]
                         ]
                         header = f"{'Key':<12} | " + " | ".join(f"{label:<12}" for _, label in cols)
-                        print(header)
-                        print("-" * 80)
+                        _safe_print(header)
+                        _safe_print("-" * 80)
                         for key, val in items:
                             values = f"{key:<12} | " + " | ".join(
                                 f"{self._format_value(val.get(col_key)):<12}" for col_key, _ in cols
                             )
-                            print(values)
+                            _safe_print(values)
                 else:
                     # flat dict
                     for k, v in list(data.items())[:limit]:
-                        print(f"  {k:<25}: {self._format_value(v)}")
+                        _safe_print(f"  {k:<25}: {self._format_value(v)}")
             
-            print("=" * 80 + "\n")
+            _safe_print("=" * 80 + "\n")
             output_data["data"] = data
             
         elif chart_type == "line":
@@ -8400,36 +8528,36 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 context.log("error", f"line 차트에 x_field, y_field 필수", node_id)
                 return {"rendered": False, "error": "x_field, y_field 필수"}
             
-            print(f"\n📈 {title or 'Line Chart'} [{now}]")
-            print("=" * 60)
+            _safe_print(f"\n📈 {title or 'Line Chart'} [{now}]")
+            _safe_print("=" * 60)
             
             if isinstance(data, list) and len(data) > 0:
                 first = data[0]
                 last = data[-1]
-                print(f"📊 데이터 포인트: {len(data)}개")
-                print(f"📅 X축 범위: {first.get(x_field)} ~ {last.get(x_field)}")
-                print(f"📈 Y축({y_field}) 시작: {self._format_value(first.get(y_field))}")
-                print(f"📈 Y축({y_field}) 끝: {self._format_value(last.get(y_field))}")
+                _safe_print(f"📊 데이터 포인트: {len(data)}개")
+                _safe_print(f"📅 X축 범위: {first.get(x_field)} ~ {last.get(x_field)}")
+                _safe_print(f"📈 Y축({y_field}) 시작: {self._format_value(first.get(y_field))}")
+                _safe_print(f"📈 Y축({y_field}) 끝: {self._format_value(last.get(y_field))}")
                 
                 # 최대/최소
                 values = [d.get(y_field, 0) for d in data if d.get(y_field) is not None]
                 if values:
-                    print(f"📈 최대: {self._format_value(max(values))}")
-                    print(f"📉 최소: {self._format_value(min(values))}")
+                    _safe_print(f"📈 최대: {self._format_value(max(values))}")
+                    _safe_print(f"📉 최소: {self._format_value(min(values))}")
                 
                 # 시그널 마커 표시
                 if signal_field:
                     signals = self._extract_signals(data, x_field, signal_field, side_field)
                     if signals:
-                        print(f"\n🎯 시그널 ({len(signals)}개):")
+                        _safe_print(f"\n🎯 시그널 ({len(signals)}개):")
                         for sig in signals[:10]:  # 최대 10개만 표시
-                            print(f"  {sig['marker']} {sig['x']} ({sig['signal']}/{sig['side']})")
+                            _safe_print(f"  {sig['marker']} {sig['x']} ({sig['signal']}/{sig['side']})")
                         if len(signals) > 10:
-                            print(f"  ... 외 {len(signals) - 10}개")
+                            _safe_print(f"  ... 외 {len(signals) - 10}개")
             else:
-                print("(데이터 없음)")
+                _safe_print("(데이터 없음)")
             
-            print("=" * 60 + "\n")
+            _safe_print("=" * 60 + "\n")
             output_data["data"] = data
             output_data["x_field"] = x_field
             output_data["y_field"] = y_field
@@ -8453,8 +8581,8 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 context.log("error", f"multi_line 차트에 x_field, y_field, series_key 필수", node_id)
                 return {"rendered": False, "error": "x_field, y_field, series_key 필수"}
             
-            print(f"\n📈 {title or 'Multi-Line Chart'} [{now}]")
-            print("=" * 80)
+            _safe_print(f"\n📈 {title or 'Multi-Line Chart'} [{now}]")
+            _safe_print("=" * 80)
             
             # data가 평탄화된 배열 형식인 경우 [{symbol, date, value, ...}, ...]
             if isinstance(data, list):
@@ -8479,29 +8607,29 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 
                 series_items = series_items[:limit]
                 
-                print(f"📊 시리즈 수: {len(series_items)}개 (limit: {limit})")
-                print("-" * 80)
-                print(f"{'Series':<12} | {'Points':<8} | {f'First {y_field}':<15} | {f'Last {y_field}':<15}")
-                print("-" * 80)
+                _safe_print(f"📊 시리즈 수: {len(series_items)}개 (limit: {limit})")
+                _safe_print("-" * 80)
+                _safe_print(f"{'Series':<12} | {'Points':<8} | {f'First {y_field}':<15} | {f'Last {y_field}':<15}")
+                _safe_print("-" * 80)
                 
                 for symbol, rows in series_items:
                     if isinstance(rows, list) and len(rows) > 0:
                         first_val = rows[0].get(y_field, 0)
                         last_val = rows[-1].get(y_field, 0)
-                        print(f"{symbol:<12} | {len(rows):<8} | {self._format_value(first_val):<15} | {self._format_value(last_val):<15}")
+                        _safe_print(f"{symbol:<12} | {len(rows):<8} | {self._format_value(first_val):<15} | {self._format_value(last_val):<15}")
                 
                 # 시그널 마커 표시
                 if signal_field:
                     signals = self._extract_signals(data, x_field, signal_field, side_field, series_key)
                     if signals:
-                        print(f"\n🎯 시그널 ({len(signals)}개):")
+                        _safe_print(f"\n🎯 시그널 ({len(signals)}개):")
                         for sig in signals[:15]:  # 최대 15개만 표시
                             series_info = f" [{sig.get('series', '')}]" if sig.get('series') else ""
-                            print(f"  {sig['marker']} {sig['x']}{series_info} ({sig['signal']}/{sig['side']})")
+                            _safe_print(f"  {sig['marker']} {sig['x']}{series_info} ({sig['signal']}/{sig['side']})")
                         if len(signals) > 15:
-                            print(f"  ... 외 {len(signals) - 15}개")
+                            _safe_print(f"  ... 외 {len(signals) - 15}개")
             
-            print("=" * 80 + "\n")
+            _safe_print("=" * 80 + "\n")
             output_data["data"] = data
             output_data["x_field"] = x_field
             output_data["y_field"] = y_field
@@ -8527,16 +8655,16 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 context.log("error", f"candlestick 차트에 date_field, open_field, high_field, low_field, close_field 필수", node_id)
                 return {"rendered": False, "error": "OHLC 필드 필수"}
             
-            print(f"\n📊 {title or 'Candlestick Chart'} [{now}]")
-            print("=" * 80)
+            _safe_print(f"\n📊 {title or 'Candlestick Chart'} [{now}]")
+            _safe_print("=" * 80)
             
             if isinstance(data, list) and len(data) > 0:
                 first = data[0]
                 last = data[-1]
-                print(f"📊 캔들 수: {len(data)}개")
-                print(f"📅 기간: {first.get(date_field)} ~ {last.get(date_field)}")
-                print(f"💵 시작 종가: {self._format_value(first.get(close_field))}")
-                print(f"💵 최종 종가: {self._format_value(last.get(close_field))}")
+                _safe_print(f"📊 캔들 수: {len(data)}개")
+                _safe_print(f"📅 기간: {first.get(date_field)} ~ {last.get(date_field)}")
+                _safe_print(f"💵 시작 종가: {self._format_value(first.get(close_field))}")
+                _safe_print(f"💵 최종 종가: {self._format_value(last.get(close_field))}")
                 
                 # 수익률
                 start_price = first.get(close_field, 0)
@@ -8545,21 +8673,21 @@ class DisplayNodeExecutor(NodeExecutorBase):
                     pct_change = (end_price - start_price) / start_price * 100
                     sign = "+" if pct_change >= 0 else ""
                     color = "\033[92m" if pct_change >= 0 else "\033[91m"
-                    print(f"📈 변동률: {color}{sign}{pct_change:.2f}%\033[0m")
+                    _safe_print(f"📈 변동률: {color}{sign}{pct_change:.2f}%\033[0m")
                 
                 # 시그널 마커 표시
                 if signal_field:
                     signals = self._extract_signals(data, date_field, signal_field, side_field)
                     if signals:
-                        print(f"\n🎯 시그널 ({len(signals)}개):")
+                        _safe_print(f"\n🎯 시그널 ({len(signals)}개):")
                         for sig in signals[:10]:  # 최대 10개만 표시
-                            print(f"  {sig['marker']} {sig['x']} ({sig['signal']}/{sig['side']})")
+                            _safe_print(f"  {sig['marker']} {sig['x']} ({sig['signal']}/{sig['side']})")
                         if len(signals) > 10:
-                            print(f"  ... 외 {len(signals) - 10}개")
+                            _safe_print(f"  ... 외 {len(signals) - 10}개")
             else:
-                print("(데이터 없음)")
+                _safe_print("(데이터 없음)")
             
-            print("=" * 80 + "\n")
+            _safe_print("=" * 80 + "\n")
             output_data["data"] = data
             output_data["date_field"] = date_field
             output_data["open_field"] = open_field
@@ -8582,23 +8710,23 @@ class DisplayNodeExecutor(NodeExecutorBase):
                 context.log("error", f"bar 차트에 x_field, y_field 필수", node_id)
                 return {"rendered": False, "error": "x_field, y_field 필수"}
             
-            print(f"\n📊 {title or 'Bar Chart'} [{now}]")
-            print("=" * 60)
+            _safe_print(f"\n📊 {title or 'Bar Chart'} [{now}]")
+            _safe_print("=" * 60)
             
             if isinstance(data, list) and len(data) > 0:
-                print(f"{'Bar':<20} | {y_field}")
-                print("-" * 60)
+                _safe_print(f"{'Bar':<20} | {y_field}")
+                _safe_print("-" * 60)
                 for item in data[:20]:
                     x_val = item.get(x_field, "")
                     y_val = item.get(y_field, 0)
-                    print(f"{str(x_val):<20} | {self._format_value(y_val)}")
+                    _safe_print(f"{str(x_val):<20} | {self._format_value(y_val)}")
             elif isinstance(data, dict):
-                print(f"{'Key':<20} | {'Value'}")
-                print("-" * 60)
+                _safe_print(f"{'Key':<20} | {'Value'}")
+                _safe_print("-" * 60)
                 for k, v in list(data.items())[:20]:
-                    print(f"{str(k):<20} | {self._format_value(v)}")
+                    _safe_print(f"{str(k):<20} | {self._format_value(v)}")
             
-            print("=" * 60 + "\n")
+            _safe_print("=" * 60 + "\n")
             output_data["data"] = data
             output_data["x_field"] = x_field
             output_data["y_field"] = y_field
@@ -13527,6 +13655,20 @@ class NewOrderNodeExecutor(NodeExecutorBase):
                 context.log("error", f"{node_type}: Unsupported product: {product}", node_id)
                 return self._error_result(f"Unsupported product: {product}")
 
+            # === 5.4. DEF-27: 접수(order number) ≠ 체결. 주문 TR 응답은 주문번호만
+            # 돌려주므로, 방금 접수된 주문의 체결 여부를 best-effort 로 재조회해
+            # order_result.status 를 submitted → filled / partially_filled / open
+            # 으로 승격하고 filled_quantity / filled_count 를 붙인다. 순수 관측용 —
+            # 재조회가 실패해도 접수 성공(success=True)은 절대 뒤집지 않는다. ===
+            if (
+                isinstance(order_result, dict)
+                and isinstance(order_result.get("order_result"), dict)
+                and order_result["order_result"].get("success") is True
+            ):
+                await self._confirm_order_fill(
+                    ls, product, order_type, order_result, config, context, node_id
+                )
+
             # === 5.5. A-4: 성공 주문 idempotency 레지스트리에 기록 ===
             context.record_order_submitted(
                 node_id=node_id,
@@ -14050,6 +14192,259 @@ class NewOrderNodeExecutor(NodeExecutorBase):
         except Exception as e:
             context.log("warning", f"Failed to sync fills after market order: {e}", node_id)
 
+    async def _confirm_order_fill(
+        self,
+        ls,
+        product: str,
+        order_type: str,
+        order_result: Dict[str, Any],
+        config: Dict[str, Any],
+        context: ExecutionContext,
+        node_id: str,
+    ) -> None:
+        """Best-effort post-submission fill confirmation (DEF-27).
+
+        A broker order TR returns the order number only (= accepted), never a
+        fill. This re-queries the order right after submission and upgrades
+        ``order_result['order_result']`` in place:
+
+        - ``status``: submitted → ``filled`` / ``partially_filled`` / ``open``
+        - adds ``filled_quantity`` / ``fill_price`` / ``filled_count``
+
+        Purely additive observability: it never raises and never flips
+        ``success``. If the re-query errors or the order is not found, the
+        order stays reported as accepted with ``status="open"`` (honest
+        "accepted, not confirmed filled").
+
+        Fills are recorded a few seconds after the accept ack, so every order is
+        polled over a short bounded window (fill_confirm_attempts ×
+        fill_confirm_delay_seconds), breaking as soon as the fill lands; an order
+        still unfilled at the end is reported "open". Per-product re-query TR:
+        korea_stock=t0425, overseas_stock=COSAQ00102, overseas_futures/option=CIDBQ02400.
+        """
+        try:
+            inner = order_result.get("order_result", {})
+            order_id = str(order_result.get("order_id") or inner.get("order_id") or "")
+            if not order_id:
+                return
+            if product not in (
+                "korea_stock", "overseas_stock", "overseas_futures", "overseas_futureoption",
+            ):
+                return  # unknown product: no fill re-query — leave as submitted
+
+            try:
+                ordered_qty = int(inner.get("quantity") or 0)
+            except (TypeError, ValueError):
+                ordered_qty = 0
+
+            # A fill is recorded to the day's order/fill query a few seconds AFTER
+            # the accept ack — even for a marketable order (live-observed on HKEX
+            # futures paper: an immediate re-query still shows unfilled). So poll a
+            # short bounded window for every order type, breaking as soon as the
+            # fill lands. A genuinely resting limit order simply exhausts the window
+            # and is reported "open" (honest). Both knobs are configurable; set
+            # fill_confirm_attempts=1 to disable polling for latency-sensitive flows.
+            try:
+                attempts = int(config.get("fill_confirm_attempts", 4))
+            except (TypeError, ValueError):
+                attempts = 4
+            try:
+                delay = float(config.get("fill_confirm_delay_seconds", 2.0))
+            except (TypeError, ValueError):
+                delay = 2.0
+            attempts = max(1, attempts)
+
+            symbol = inner.get("symbol", "")
+            filled_qty, fill_price = 0, 0.0
+            for i in range(attempts):
+                # Query immediately first (catches an already-recorded fill at no
+                # cost), then wait between retries for the lagged fill to land.
+                if i > 0:
+                    await asyncio.sleep(delay)
+                if product == "korea_stock":
+                    filled_qty, fill_price = await self._query_korea_fill(
+                        ls, order_id, symbol, context, node_id
+                    )
+                elif product == "overseas_stock":
+                    filled_qty, fill_price = await self._query_overseas_stock_fill(
+                        ls, order_id, context, node_id
+                    )
+                else:  # overseas_futures / overseas_futureoption
+                    filled_qty, fill_price = await self._query_overseas_futures_fill(
+                        ls, order_id, context, node_id
+                    )
+                if ordered_qty > 0 and filled_qty >= ordered_qty:
+                    break
+
+            if ordered_qty > 0 and filled_qty >= ordered_qty:
+                inner["status"] = "filled"
+                inner["filled_count"] = 1
+            elif filled_qty > 0:
+                inner["status"] = "partially_filled"
+                inner["filled_count"] = 0
+            else:
+                inner["status"] = "open"
+                inner["filled_count"] = 0
+            inner["filled_quantity"] = filled_qty
+            if fill_price > 0:
+                inner["fill_price"] = fill_price
+
+            context.log(
+                "info",
+                f"Fill confirm: order {order_id} → {inner['status']} "
+                f"({filled_qty}/{ordered_qty})",
+                node_id,
+            )
+        except Exception as e:
+            # Best-effort: a re-query failure must not disturb the (successful)
+            # order submission. Leave order_result untouched (status stays
+            # "submitted").
+            context.log("debug", f"Fill confirmation skipped (best-effort): {e}", node_id)
+
+    async def _query_korea_fill(
+        self,
+        ls,
+        order_id: str,
+        symbol: str,
+        context: ExecutionContext,
+        node_id: str,
+    ) -> tuple:
+        """Return ``(filled_qty, avg_fill_price)`` for a korea_stock order via
+        t0425 (당일 체결/미체결 조회). ``(0, 0.0)`` when not found or on error."""
+        try:
+            from programgarden_finance.ls.korea_stock.accno.t0425.blocks import T0425InBlock
+
+            # expcode 는 빈값(전체 종목)으로 둔다 — 주문번호(ordno)가 authoritative
+            # 매칭 키이고, 심볼 포맷 차이('005930' vs 'A005930' 등)로 내 주문을
+            # 놓치는 것을 피한다. symbol 인자는 로깅/시그니처 호환용으로만 유지.
+            _ = symbol
+            response = await ls.korea_stock().accno().t0425(
+                body=T0425InBlock(
+                    expcode="",           # 전체 종목 (ordno 로 매칭)
+                    chegb="0",            # 0: 전체(체결+미체결) — 상태 판정에 필요
+                    medosu="0",           # 0: 전체
+                    sortgb="1",           # 1: 주문번호 역순(방금 낸 주문이 앞쪽)
+                    cts_ordno="",
+                )
+            ).req_async()
+
+            if getattr(response, "error_msg", None):
+                context.log("debug", f"t0425 fill query error: {response.error_msg}", node_id)
+                return 0, 0.0
+
+            for item in getattr(response, "block", None) or []:
+                if str(getattr(item, "ordno", "")) == order_id:
+                    filled_qty = int(getattr(item, "cheqty", 0) or 0)
+                    fill_price = float(getattr(item, "cheprice", 0) or 0)
+                    return filled_qty, fill_price
+            return 0, 0.0
+        except Exception as e:
+            context.log("debug", f"t0425 fill query exception: {e}", node_id)
+            return 0, 0.0
+
+    async def _query_overseas_stock_fill(
+        self,
+        ls,
+        order_id: str,
+        context: ExecutionContext,
+        node_id: str,
+    ) -> tuple:
+        """Return ``(filled_qty, avg_fill_price)`` for an overseas_stock order
+        via COSAQ00102 (주문체결내역조회, 체결분만). ``(0, 0.0)`` when not found
+        or on error."""
+        try:
+            from programgarden_finance import COSAQ00102
+            from datetime import datetime as _dt
+
+            today = _dt.now().strftime("%Y%m%d")
+            response = ls.overseas_stock().accno().cosaq00102(
+                body=COSAQ00102.COSAQ00102InBlock1(
+                    RecCnt=1,
+                    QryTpCode="1",       # 계좌별
+                    BkseqTpCode="1",     # 역순
+                    OrdMktCode="00",     # 전체 시장
+                    BnsTpCode="0",       # 전체(매수/매도)
+                    IsuNo="",            # 전체 종목
+                    SrtOrdNo=999999999,  # 역순 시작
+                    OrdDt=today,
+                    ExecYn="1",          # 1: 체결만
+                    CrcyCode="000",      # 전체 통화
+                    ThdayBnsAppYn="0",
+                    LoanBalHldYn="0",
+                ),
+            )
+            result = await response.req_async()
+            if not result or not getattr(result, "block3", None):
+                return 0, 0.0
+
+            filled_qty = 0
+            amount = 0.0
+            for item in result.block3:
+                if str(getattr(item, "OrdNo", 0)) != order_id:
+                    continue
+                q = int(getattr(item, "ExecQty", 0) or 0)
+                p = float(
+                    getattr(item, "OvrsExecPrc", 0) or getattr(item, "OvrsOrdPrc", 0) or 0
+                )
+                filled_qty += q
+                amount += q * p
+            avg_price = (amount / filled_qty) if filled_qty > 0 else 0.0
+            return filled_qty, avg_price
+        except Exception as e:
+            context.log("debug", f"COSAQ00102 fill query exception: {e}", node_id)
+            return 0, 0.0
+
+    async def _query_overseas_futures_fill(
+        self,
+        ls,
+        order_id: str,
+        context: ExecutionContext,
+        node_id: str,
+    ) -> tuple:
+        """Return ``(filled_qty, avg_fill_price)`` for an overseas_futures/option
+        order via CIDBQ02400 (당일 주문체결내역, 전체). ``(0, 0.0)`` when not
+        found or on error. Also covers HKEX-futures paper accounts."""
+        try:
+            from programgarden_finance.ls.overseas_futureoption.accno.CIDBQ02400.blocks import (
+                CIDBQ02400InBlock1,
+            )
+            from datetime import datetime as _dt
+
+            today = _dt.now().strftime("%Y%m%d")
+            response = await ls.overseas_futureoption().accno().CIDBQ02400(
+                body=CIDBQ02400InBlock1(
+                    IsuCodeVal="",          # 전체 종목
+                    QrySrtDt=today,
+                    QryEndDt=today,
+                    ThdayTpCode="1",        # 1: 당일조회
+                    OrdStatCode="0",        # 0: 전체(체결+미체결) — 상태 판정에 필요
+                    BnsTpCode="0",          # 0: 전체
+                    QryTpCode="1",          # 1: 역순(방금 낸 주문이 앞쪽)
+                    OrdPtnCode="00",        # 00: 전체
+                    OvrsDrvtFnoTpCode="A",  # A: 전체(선물+옵션)
+                )
+            ).req_async()
+
+            if getattr(response, "error_msg", None):
+                context.log("debug", f"CIDBQ02400 fill query error: {response.error_msg}", node_id)
+                return 0, 0.0
+
+            # block2 = 주문/체결 상세 (한 주문에 다중 체결이면 행이 여럿 → ExecQty 합산)
+            filled_qty = 0
+            amount = 0.0
+            for item in getattr(response, "block2", None) or []:
+                if str(getattr(item, "OvrsFutsOrdNo", "")) != order_id:
+                    continue
+                q = int(getattr(item, "ExecQty", 0) or 0)
+                p = float(getattr(item, "AbrdFutsExecPrc", 0) or 0)
+                filled_qty += q
+                amount += q * p
+            avg_price = (amount / filled_qty) if filled_qty > 0 else 0.0
+            return filled_qty, avg_price
+        except Exception as e:
+            context.log("debug", f"CIDBQ02400 fill query exception: {e}", node_id)
+            return 0, 0.0
+
     async def _execute_overseas_futures(
         self,
         ls,
@@ -17847,7 +18242,7 @@ class WorkflowJob:
         except asyncio.CancelledError:
             self.status = "cancelled"
             logger.info(f"Job {self.job_id} cancelled")
-            print(f"⚠️ Job {self.job_id} cancelled")
+            _safe_print(f"[CANCELLED] Job {self.job_id} cancelled")
             await self.context.notify_job_state("cancelled", self.stats)
         except Exception as e:
             self.status = "failed"
@@ -17864,9 +18259,17 @@ class WorkflowJob:
                 }
             self.context.log("error", error_msg)
             logger.exception(f"Job {self.job_id} failed: {e}")
-            print(f"❌ Job {self.job_id} failed: {e}")
+            # ASCII-only marker: this is the failure-reporting path, so it must
+            # survive a console that could not render the text that failed.
+            _safe_print(f"[FAILED] Job {self.job_id} failed: {e}")
             import traceback
-            traceback.print_exc()
+            try:
+                # print_exc renders the offending source line, which may itself
+                # hold the character that could not be encoded — so it can raise
+                # the very error it is reporting.
+                traceback.print_exc()
+            except Exception:
+                logger.debug("traceback output dropped", exc_info=True)
             await self.context.notify_job_state("failed", self.stats)
 
             # WORKFLOW_FAILED notification
@@ -17940,7 +18343,7 @@ class WorkflowJob:
             skip_nodes: 복구 모드에서 이미 완료된 노드 ID 집합 (스킵)
         """
         skip_nodes = skip_nodes or set()
-        print(f"🔄 Executing main flow: {self.workflow.execution_order}")
+        _safe_print(f"🔄 Executing main flow: {self.workflow.execution_order}")
 
         # === Item-based execution setup ===
         # Find Split/Aggregate pairs and their branch nodes
@@ -17980,7 +18383,7 @@ class WorkflowJob:
 
             # === Checkpoint restore: 이미 완료된 노드 스킵 ===
             if node_id in skip_nodes:
-                print(f"  ⏭ Skipping restored node: {node_id} ({node.node_type})")
+                _safe_print(f"  ⏭ Skipping restored node: {node_id} ({node.node_type})")
                 self._completed_node_ids.add(node_id)
                 await self.context.notify_node_state(
                     node_id=node_id,
@@ -17991,7 +18394,7 @@ class WorkflowJob:
 
             # === Item-based execution: Skip branch nodes (handled by SplitNode) ===
             if node_id in branch_nodes and node.node_type not in ("SplitNode", "AggregateNode"):
-                print(f"  ⏭ Skipping branch node: {node_id} (handled by SplitNode)")
+                _safe_print(f"  ⏭ Skipping branch node: {node_id} (handled by SplitNode)")
                 continue
 
             # === Item-based execution: Handle SplitNode specially ===
@@ -18002,12 +18405,12 @@ class WorkflowJob:
 
             # === Item-based execution: Skip AggregateNode (already executed by SplitNode) ===
             if node.node_type == "AggregateNode" and node_id in split_aggregate_pairs.values():
-                print(f"  ⏭ Skipping AggregateNode: {node_id} (already executed by SplitNode)")
+                _safe_print(f"  ⏭ Skipping AggregateNode: {node_id} (already executed by SplitNode)")
                 continue
 
             # === IfNode: 비활성 브랜치 스킵 ===
             if node_id in if_skipped_nodes:
-                print(f"  ⏭ Skipping node: {node_id} (IfNode branch not taken)")
+                _safe_print(f"  ⏭ Skipping node: {node_id} (IfNode branch not taken)")
                 await self.context.notify_node_state(
                     node_id=node_id,
                     node_type=node.node_type,
@@ -18015,7 +18418,7 @@ class WorkflowJob:
                 )
                 continue
 
-            print(f"  ▶ Executing node: {node_id} ({node.node_type})")
+            _safe_print(f"  ▶ Executing node: {node_id} ({node.node_type})")
             
             # 🆕 노드 실행 시작 알림
             start_time = datetime.utcnow()
@@ -18186,7 +18589,7 @@ class WorkflowJob:
                     new_skips = self._compute_if_skip_nodes(node_id, taken)
                     if_skipped_nodes.update(new_skips)
                     if new_skips:
-                        print(f"  🔀 IfNode {node_id}: branch={taken}, skipping {new_skips}")
+                        _safe_print(f"  🔀 IfNode {node_id}: branch={taken}, skipping {new_skips}")
 
                 # deep_validate: a node that *returns* a sole-`error` dict (rather
                 # than raising) would otherwise be stored as a COMPLETED output and
@@ -18225,6 +18628,53 @@ class WorkflowJob:
                         },
                     )
 
+                # An order node that failed did NOT raise — it returned
+                # order_result.success=False. Reporting that as COMPLETED leaves
+                # errors_count=0 / last_error=None, i.e. every observable surface
+                # says the run succeeded while no order actually went out. Surface
+                # it: FAILED node state + job stats + an error log line. no_signal
+                # ("no trading signal today") is a normal no-op and is excluded.
+                order_failure = _order_failure_from_outputs(outputs)
+
+                # DEF-26/DEF-27: wire the previously-dead orders_placed /
+                # orders_filled counters. placed = orders this node actually
+                # submitted (accepted by the broker); filled = orders a
+                # post-submit re-query confirmed as fully traded. Both are 0 for
+                # non-order nodes and for failed orders, so this is safe to run
+                # unconditionally for every node.
+                self.stats["orders_placed"] += _orders_placed_from_outputs(outputs)
+                self.stats["orders_filled"] += _orders_filled_from_outputs(outputs)
+
+                # deep_validate: promote it to a blocking structured error so the
+                # chatbot learns its order wiring is broken at *build* time instead
+                # of shipping a workflow whose order silently never fires.
+                if (
+                    order_failure
+                    and getattr(self.context, "is_deep_validate", False)
+                    and node_id not in self._node_error_infos
+                ):
+                    from programgarden_core import (
+                        ErrorCode,
+                        ErrorLocation,
+                        build_error,
+                    )
+                    self._node_error_infos[node_id] = build_error(
+                        ErrorCode.DEEP_VALIDATION_NODE_ERROR,
+                        f"Node '{node_id}' ({node.node_type}) placed no order: "
+                        f"{order_failure}",
+                        location=ErrorLocation(node_id=node_id, node_type=node.node_type),
+                        suggestion=(
+                            "주문 노드가 주문을 내지 못했습니다. 상류 노드의 출력이 이 노드의 "
+                            "주문 입력(order/orders)에 실제로 연결되어 있는지, 표현식이 "
+                            "해소되는지, 수량·종목이 채워지는지 확인하세요."
+                        ),
+                        details={
+                            "raw_message": order_failure,
+                            "deep_validate": True,
+                            "stage": "order_not_placed",
+                        },
+                    )
+
                 # Store outputs
                 for out_port_name, value in outputs.items():
                     self.context.set_output(node_id, out_port_name, value)
@@ -18233,16 +18683,39 @@ class WorkflowJob:
                 # stay_connected 노드는 RUNNING 상태 유지 (계속 실시간 업데이트)
                 duration_ms = (datetime.utcnow() - start_time).total_seconds() * 1000
                 is_stay_connected = node_id in self._stay_connected_nodes
-                
-                await self.context.notify_node_state(
-                    node_id=node_id,
-                    node_type=node.node_type,
-                    state=NodeState.RUNNING if is_stay_connected else NodeState.COMPLETED,
-                    outputs=outputs,
-                    duration_ms=duration_ms,
-                )
+
+                if order_failure:
+                    await self.context.notify_node_state(
+                        node_id=node_id,
+                        node_type=node.node_type,
+                        state=NodeState.FAILED,
+                        outputs=outputs,
+                        error=order_failure,
+                        duration_ms=duration_ms,
+                    )
+                    self.stats["errors_count"] += 1
+                    self.stats["last_error"] = f"{node_id}: {order_failure}"
+                    self.stats["last_error_detail"] = {
+                        "node_id": node_id,
+                        "node_type": node.node_type,
+                        "error": order_failure,
+                        "timestamp": datetime.utcnow().isoformat(),
+                    }
+                    self.context.log(
+                        "error", f"Order not placed by {node_id}: {order_failure}", node_id
+                    )
+                else:
+                    await self.context.notify_node_state(
+                        node_id=node_id,
+                        node_type=node.node_type,
+                        state=NodeState.RUNNING if is_stay_connected else NodeState.COMPLETED,
+                        outputs=outputs,
+                        duration_ms=duration_ms,
+                    )
 
                 # Checkpoint: 노드 완료 추적 + 일회성 워크플로우 노드 완료마다 저장
+                # (실패해도 흐름은 계속한다 — 스케줄 잡이 한 사이클의 주문 실패로
+                #  통째로 죽지 않도록. 관측 표면에는 위에서 이미 실패로 남았다.)
                 self._completed_node_ids.add(node_id)
                 if not self._stay_connected_nodes:
                     await self._save_checkpoint()
@@ -18417,7 +18890,7 @@ class WorkflowJob:
         all_results = []
         total = len(items)
 
-        print(f"  🔄 Auto-iterate: {node_id} ({node.node_type}) - {total} items")
+        _safe_print(f"  🔄 Auto-iterate: {node_id} ({node.node_type}) - {total} items")
 
         for idx, current_item in enumerate(items):
             # === item, index, total을 ExecutionContext에 설정 ===
@@ -18428,7 +18901,7 @@ class WorkflowJob:
 
             # 진행 상황 로그
             item_label = current_item.get("symbol", str(current_item)) if isinstance(current_item, dict) else str(current_item)
-            print(f"    [{idx+1}/{total}] Processing: {item_label}")
+            _safe_print(f"    [{idx+1}/{total}] Processing: {item_label}")
             self.context.log("debug", f"Auto-iterate [{idx+1}/{total}]: {item_label}", node_id)
 
             # A-3: per-item spacing for order / external-API nodes
@@ -18461,7 +18934,7 @@ class WorkflowJob:
 
         # 결과 병합: 배열 필드는 병합, 단일 필드는 마지막 값
         merged = self._merge_iterate_results(all_results)
-        print(f"  ✅ Auto-iterate complete: {len(all_results)} results merged")
+        _safe_print(f"  ✅ Auto-iterate complete: {len(all_results)} results merged")
 
         return merged
 
@@ -18655,7 +19128,7 @@ class WorkflowJob:
         """
         from programgarden_core.bases.listener import NodeState
 
-        print(f"  🔀 Executing SplitNode branch: {split_id}")
+        _safe_print(f"  🔀 Executing SplitNode branch: {split_id}")
 
         # Get paired AggregateNode
         aggregate_id = split_aggregate_pairs.get(split_id)
@@ -18744,7 +19217,7 @@ class WorkflowJob:
         results_by_index: Dict[int, Any] = {}
         errors: List[str] = []
 
-        print(f"    📦 SplitNode: {total} items, parallel={parallel}, delay_ms={delay_ms}")
+        _safe_print(f"    📦 SplitNode: {total} items, parallel={parallel}, delay_ms={delay_ms}")
 
         # === Execute branch for each item ===
         if parallel:
@@ -18991,7 +19464,7 @@ class WorkflowJob:
         if not node:
             return
 
-        print(f"  🔗 Executing AggregateNode: {aggregate_id}")
+        _safe_print(f"  🔗 Executing AggregateNode: {aggregate_id}")
 
         start_time = datetime.utcnow()
         await self.context.notify_node_state(
@@ -19458,24 +19931,24 @@ class WorkflowJob:
         Follows topological order to ensure proper data flow.
         """
         from datetime import datetime
-        print(f"[{datetime.now().strftime('%H:%M:%S')}] 🔄 실시간 업데이트 이벤트 수신: trigger_nodes={event.trigger_nodes}")
+        _safe_print(f"[{datetime.now().strftime('%H:%M:%S')}] 🔄 실시간 업데이트 이벤트 수신: trigger_nodes={event.trigger_nodes}")
         
         # trigger_nodes가 비어있으면 source_node_id에서 연결된 하위 노드 찾기
         trigger_nodes = event.trigger_nodes
         if not trigger_nodes and event.source_node_id:
             trigger_nodes = self._find_trigger_nodes(event.source_node_id)
-            print(f"  → 자동 탐색된 trigger_nodes: {trigger_nodes}")
+            _safe_print(f"  → 자동 탐색된 trigger_nodes: {trigger_nodes}")
         
         if not trigger_nodes:
-            print(f"  ⚠️ 트리거할 노드 없음, 스킵")
+            _safe_print(f"  ⚠️ 트리거할 노드 없음, 스킵")
             return
         
         logger.debug(f"Realtime update from {event.source_node_id}, triggering: {trigger_nodes}")
-        print(f"  → {event.source_node_id}에서 트리거: {trigger_nodes}")
+        _safe_print(f"  → {event.source_node_id}에서 트리거: {trigger_nodes}")
         
         # 🆕 트리거된 노드들 + 하위 노드들을 모두 찾아서 실행 순서대로 정렬
         nodes_to_execute = self._find_downstream_nodes(trigger_nodes)
-        print(f"  → 실행할 노드 체인: {nodes_to_execute}")
+        _safe_print(f"  → 실행할 노드 체인: {nodes_to_execute}")
 
         # Split→Aggregate 분기는 노드를 하나씩 재실행해서는 절대 채워지지 않는다.
         # AggregateNode 의 유일한 입력인 node_state["_collected_items"] 를 쓰는 곳은
@@ -19492,7 +19965,7 @@ class WorkflowJob:
             split_node = self.workflow.nodes.get(split_id)
             if not split_node:
                 continue
-            print(f"    🔀 Re-driving split branch: {split_id} → {aggregate_id}")
+            _safe_print(f"    🔀 Re-driving split branch: {split_id} → {aggregate_id}")
             await self._execute_split_branch(split_id, split_node, split_pairs, branch)
             branch_driven |= branch | {split_id, aggregate_id}
 
@@ -19514,7 +19987,7 @@ class WorkflowJob:
 
             # Re-execute the triggered node
             try:
-                print(f"    ▶ Re-executing: {node_id} ({node.node_type})")
+                _safe_print(f"    ▶ Re-executing: {node_id} ({node.node_type})")
                 
                 # 소스 노드 ID를 config에 추가하여 최신 데이터 참조 가능하게
                 config_with_source = dict(node.config)
@@ -19694,7 +20167,17 @@ class WorkflowJob:
                     await self._task
                 except asyncio.CancelledError:
                     pass
-        
+
+        # Cleanup persistent trackers / flow-end nodes / broker·JIF 구독.
+        # 여태 stop() 은 이 정리를 빼먹어(cancel() 에만 있었다) 잡이 stop 으로 끝나면
+        # 계좌 추적기의 주기 폴링 루프가 취소되지 않고 무한히 LS 를 계속 조회했다(레이트
+        # 리밋·불필요 호출 유발). cleanup_* 는 끝에서 딕셔너리를 비우므로 _run 의 정상완료
+        # 경로가 먼저 정리했더라도 여기서 다시 불려도 빈 순회 = no-op(멱등).
+        await self._cleanup_broker_fill_subscriptions()
+        await self._cleanup_jif_subscriptions()
+        await self.context.cleanup_persistent_nodes()
+        await self.context.cleanup_flow_end_nodes()
+
         # Cleanup RiskTracker flush
         if self.context.risk_tracker:
             try:

{programgarden-1.29.2 → programgarden-1.29.4}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.29.2"
+version = "1.29.4"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"