programgarden 1.33.2__tar.gz → 1.33.4__tar.gz

{programgarden-1.33.2 → programgarden-1.33.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.33.2
+Version: 1.33.4
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -17,7 +17,7 @@ Requires-Dist: litellm (>=1.40.0)
 Requires-Dist: lxml (>=6.0.2,<7.0.0)
 Requires-Dist: programgarden-community (>=1.15.0,<2.0.0)
 Requires-Dist: programgarden-core (>=1.25.0,<2.0.0)
-Requires-Dist: programgarden-finance (>=1.9.1,<2.0.0)
+Requires-Dist: programgarden-finance (>=1.9.3,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)

{programgarden-1.33.2 → programgarden-1.33.4}/programgarden/executor.py

@@ -778,6 +778,260 @@ def evaluate_all_bindings(
     return {k: evaluate_value(v) for k, v in config.items()}
 
 
+# ---------------------------------------------------------------------------
+# D2 (AI 모델 벤치마크 2026-09-06): "No symbols provided" 3분류
+#
+# 사이징/과거시세/현재가 노드가 빈 종목 목록을 받는 원인은 세 가지인데, 종전에는 전부
+# 같은 warning("No symbols provided …")으로 찍혔다. 챗봇 저장 게이트(pg-ai
+# `_detect_input_warnings`)는 그 문구를 "설계 결함" 으로 읽어 저장을 막으므로, 조건을
+# 올바르게 배선한 워크플로우가 **모의 실행 표본에서 오늘 조건을 통과한 종목이 0** 이라는
+# 이유만으로 저장되지 못했다(벤치 본선: 모델 무관 최대 실패 원인, 40여 건 중 대부분이
+# `symbols: {{ nodes.rsi.passed_symbols }}` / `{{ nodes.filter.symbols }}` 정상 배선).
+#
+#   no_signal  — 원본 설정에 바인딩(또는 입력 포트)이 있고 상류가 이번 실행에서 빈 목록을
+#                냈다. 정상 런타임(오늘 신호 없음). info 로만 남기고 경고를 찍지 않는다.
+#   unresolved — 바인딩 표현식이 리터럴로 남았다(없는 노드/포트, 반복 밖의 `{{ item }}`).
+#   unbound    — symbols/symbol 자체가 없다(종목 소스 미연결).
+# 뒤의 둘은 설계 결함이라 종전처럼 warning("No symbols provided …") 을 유지한다 — 게이트가
+# 계속 잡아야 하는 케이스다.
+# ---------------------------------------------------------------------------
+EMPTY_SYMBOLS_NO_SIGNAL = "no_signal"
+EMPTY_SYMBOLS_UNRESOLVED = "unresolved"
+EMPTY_SYMBOLS_UNBOUND = "unbound"
+EMPTY_SYMBOLS_UPSTREAM_FAILED = "upstream_failed"   # 참조한 노드가 error/fetch_failed 를 냈다
+
+_EMPTY_VALUES = (None, "", [], {}, ())
+
+
+def _raw_node_config(node_id: str, workflow: Any, fallback: Dict[str, Any]) -> Dict[str, Any]:
+    """`ResolvedWorkflow.nodes[node_id].config` (평가 전 원본). 없으면 fallback."""
+    try:
+        nodes = getattr(workflow, "nodes", None)
+        node = nodes.get(node_id) if isinstance(nodes, dict) else None
+    except Exception:
+        node = None
+    cfg = getattr(node, "config", None)
+    return cfg if isinstance(cfg, dict) else fallback
+
+
+def _input_namespace(context: "ExecutionContext", node_id: str) -> Dict[str, Any]:
+    """`_input_<node_id>` 의사 노드(엣지로 들어온 상류 출력 전체). 없으면 {}."""
+    try:
+        outputs = context.get_all_outputs(f"_input_{node_id}")
+    except Exception:
+        return {}
+    return outputs if isinstance(outputs, dict) else {}
+
+
+def _contains_expression(value: Any) -> bool:
+    if isinstance(value, str):
+        return "{{" in value
+    if isinstance(value, dict):
+        return any(_contains_expression(v) for v in value.values())
+    if isinstance(value, list):
+        return any(_contains_expression(v) for v in value)
+    return False
+
+
+def _first_expression(value: Any) -> Optional[str]:
+    if isinstance(value, str):
+        return value if "{{" in value else None
+    if isinstance(value, dict):
+        for v in value.values():
+            found = _first_expression(v)
+            if found:
+                return found
+    if isinstance(value, list):
+        for v in value:
+            found = _first_expression(v)
+            if found:
+                return found
+    return None
+
+
+def _referenced_node_failure(expr: Optional[str], context: "ExecutionContext") -> Optional[str]:
+    """`{{ nodes.<id>.<port> }}` 가 가리키는 노드의 FULL 출력에 실패 신호(error /
+    reason=fetch_failed / _partial_failure)가 있으면 그 사유, 없으면 None.
+
+    MarketData/HistoricalData 는 조회 실패를 raise 하지 않고 ``{"values": [], "error": …}``
+    로 돌려주므로, 그 ``values`` 를 symbols 로 묶은 하류는 빈 목록만 보고 "오늘 신호 없음"
+    으로 오판할 수 있다 — 여기서 참조 노드 자체를 본다.
+    """
+    if not isinstance(expr, str) or context is None:
+        return None
+    import re as _re
+
+    m = _re.search(r"nodes\.([A-Za-z0-9_\-]+)", expr)
+    if not m:
+        return None
+    try:
+        outputs = context.get_all_outputs(m.group(1))
+    except Exception:
+        return None
+    if not isinstance(outputs, dict) or not outputs:
+        return None
+    return NewOrderNodeExecutor._extract_upstream_error(outputs)
+
+
+# 심볼을 나르는 포트 — `{{ item }}` 이 반복 밖에서 리터럴로 남았을 때 "상류 배열이 비어
+# 반복이 안 일어났다" 를 판정할 축. 메인 루프의 auto-iterate 소스 우선순위(명시 from_port
+# > symbols > 첫 출력)와 맞춘다: ConditionNode 는 0건 통과일 때도 ``symbols``(평가 대상 전체)·
+# ``failed_symbols``·``symbol_results`` 가 **비어 있지 않으므로**, 모든 리스트 포트가 비어야
+# 한다는 규칙은 D2 가 없애려던 바로 그 케이스(조건 미통과 → `symbol: {{ item }}` 경고)를
+# 남긴다. passed_symbols 가 있으면 그것만, 없으면 symbols, 둘 다 없으면 전체 리스트 포트.
+_ITERATION_SYMBOL_PORTS = ("passed_symbols", "symbols", "items", "values")
+
+
+def _upstream_array_is_empty(inputs: Dict[str, Any]) -> Optional[bool]:
+    """True = 반복 소스 배열이 비어 있다(no_signal), False = 배열이 있는데 반복이 안 걸렸다
+    (설계 결함), None = 리스트 포트가 하나도 없다."""
+    for port in _ITERATION_SYMBOL_PORTS:
+        if port in inputs and isinstance(inputs[port], list):
+            return len(inputs[port]) == 0
+    list_ports = [v for k, v in inputs.items() if isinstance(v, list) and not str(k).startswith("_")]
+    if not list_ports:
+        return None
+    return all(len(v) == 0 for v in list_ports)
+
+
+def classify_empty_symbol_source(
+    node_id: str,
+    evaluated_config: Dict[str, Any],
+    context: "ExecutionContext",
+    workflow: Any = None,
+    keys: Tuple[str, ...] = ("symbols", "symbol"),
+) -> Tuple[str, str]:
+    """빈 종목 입력의 원인을 (kind, detail) 로 돌려준다.
+
+    kind ∈ {EMPTY_SYMBOLS_NO_SIGNAL, EMPTY_SYMBOLS_UNRESOLVED, EMPTY_SYMBOLS_UNBOUND}.
+    detail 은 사람이 읽는 한 문장(영문 — 챗봇 fix_hint 로 그대로 실린다).
+
+    판정 순서:
+      1. 평가된 값에 `{{ … }}` 가 리터럴로 남아 있다 → 미해석.
+         단 `{{ item }}`/`{{ index }}` 인데 반복 컨텍스트가 없으면, 상류 배열이 비어
+         반복이 안 일어난 것(no_signal)과 배열 소스 없이 item 바인딩을 쓴 것(unresolved)을
+         `_input_<id>` 의 리스트 포트로 가른다.
+      2. 원본 설정에 바인딩/리터럴이 있었거나 입력 포트로 값이 들어왔다 → 상류가 빈 목록을
+         낸 것(no_signal). 원본이 표현식 없는 리터럴 목록인데 정규화 결과가 비었다면 항목
+         모양이 틀린 것(unbound 로 분류하되 detail 로 알린다).
+      3. 그 외 → 종목 소스 미연결(unbound).
+    """
+    import re as _re
+
+    item_re = _re.compile(r"\{\{\s*(item|index)\b")
+    raw = _raw_node_config(node_id, workflow, evaluated_config)
+    inputs = _input_namespace(context, node_id)
+    iterating = getattr(context, "_iteration_item", None) is not None
+
+    # 1) 미해석 표현식
+    for key in keys:
+        value = evaluated_config.get(key)
+        expr = _first_expression(value)
+        if not expr:
+            continue
+        if item_re.search(expr) and not iterating:
+            empty = _upstream_array_is_empty(inputs)
+            if empty is True:
+                return (
+                    EMPTY_SYMBOLS_NO_SIGNAL,
+                    f"`{key}: {expr}` — the upstream symbol array is empty in this run "
+                    "(no symbol passed / nothing to iterate), so this node was not iterated (no signal)",
+                )
+            return (
+                EMPTY_SYMBOLS_UNRESOLVED,
+                f"`{key}: {expr}` is an item binding but this node is not being iterated — "
+                "`{{ item }}` only resolves when this node is auto-iterated over an upstream "
+                "array (WatchlistNode.symbols / ConditionNode.passed_symbols / SymbolFilterNode.symbols); "
+                "inside a SplitNode branch use `{{ nodes.<split>.item }}` instead",
+            )
+        return (
+            EMPTY_SYMBOLS_UNRESOLVED,
+            f"`{key}: {expr}` did not resolve — check the node id and output port "
+            "(e.g. `{{ nodes.<condition>.passed_symbols }}` / `{{ nodes.<filter>.symbols }}`)",
+        )
+
+    # 2) 바인딩/입력 포트는 있는데 결과가 빈 목록
+    bound_key = None
+    for key in keys:
+        if raw.get(key) not in _EMPTY_VALUES:
+            bound_key = key
+            break
+    port_key = next((k for k in keys if k in inputs), None)
+
+    if bound_key is not None:
+        raw_value = raw[bound_key]
+        if _contains_expression(raw_value):
+            expr = _first_expression(raw_value)
+            resolved = evaluated_config.get(bound_key)
+            # 참조한 노드 자체가 실패했다(MarketData/HistoricalData 의 `{"values": [], "error": …}`,
+            # reason=fetch_failed, _partial_failure) → 빈 목록은 신호 없음이 아니라 파이프라인 고장.
+            failure = _referenced_node_failure(expr, context)
+            if failure:
+                return (
+                    EMPTY_SYMBOLS_UPSTREAM_FAILED,
+                    f"upstream node referenced by `{bound_key}: {expr}` failed: {failure}",
+                )
+            # 표현식이 **빈 목록이 아니라 None** 으로 풀렸다 = 참조한 노드/포트가 없다
+            # (평가기는 없는 포트를 None 으로 관대하게 푼다). 실제 종목 소스(ConditionNode.
+            # passed_symbols / SymbolFilterNode.symbols …)는 비어도 항상 [] 를 낸다.
+            if resolved is None and bound_key not in inputs:
+                return (
+                    EMPTY_SYMBOLS_UNRESOLVED,
+                    f"`{bound_key}: {expr}` resolved to nothing — the referenced node id or "
+                    "output port does not exist (check the spelling; e.g. "
+                    "`{{ nodes.<condition>.passed_symbols }}` / `{{ nodes.<filter>.symbols }}`)",
+                )
+            # 스칼라(bool/int/str)로 풀렸다 = 종목 목록이 아닌 포트를 묶었다(`result` /
+            # `is_condition_met` / `count`). 매 실행 빈 목록이 되는 영구 결함이라 warning.
+            if resolved is not None and not isinstance(resolved, (list, dict)):
+                return (
+                    EMPTY_SYMBOLS_UNRESOLVED,
+                    f"`{bound_key}: {expr}` resolved to a {type(resolved).__name__} "
+                    f"({str(resolved)[:40]!r}), not a symbol list — bind a list port "
+                    "(`passed_symbols` / `symbols`), not `result` / `is_condition_met` / `count`",
+                )
+            return (
+                EMPTY_SYMBOLS_NO_SIGNAL,
+                f"upstream symbol source `{bound_key}: {expr}` "
+                "produced no symbols in this run (no signal)",
+            )
+        if isinstance(raw_value, (list, dict)):
+            return (
+                EMPTY_SYMBOLS_UNBOUND,
+                f"`{bound_key}` is a literal list but none of its entries is a usable "
+                "{symbol, exchange} object or symbol string",
+            )
+        return (
+            EMPTY_SYMBOLS_NO_SIGNAL,
+            f"symbol source `{bound_key}` resolved to nothing in this run (no signal)",
+        )
+    if port_key is not None:
+        port_value = inputs.get(port_key)
+        # 엣지로 들어온 포트가 **비어 있지 않은데** 이 노드가 빈 목록을 봤다 = 이 노드는
+        # 입력 포트를 읽지 않는다(사이징은 evaluated config 만 본다). 바인딩을 명시해야
+        # 하는 설계 결함이지 "오늘 신호 없음" 이 아니다.
+        if port_value not in _EMPTY_VALUES:
+            return (
+                EMPTY_SYMBOLS_UNBOUND,
+                f"the upstream node emits a non-empty `{port_key}` list but this node has no "
+                f"`{port_key}` binding to consume it — bind `{port_key}: "
+                "{{ nodes.<upstream>." + port_key + " }}` explicitly",
+            )
+        return (
+            EMPTY_SYMBOLS_NO_SIGNAL,
+            f"the upstream node wired into this node emitted an empty `{port_key}` list "
+            "in this run (no signal)",
+        )
+
+    # 3) 소스 없음
+    return (
+        EMPTY_SYMBOLS_UNBOUND,
+        "no symbol source is configured — bind `symbols` to an upstream list "
+        "(`{{ nodes.<condition>.passed_symbols }}` / `{{ nodes.<filter>.symbols }}` / "
+        "`{{ nodes.<watchlist>.symbols }}`) or `symbol` to `{{ item }}` inside a per-symbol loop",
+    )
+
+
 class GenericNodeExecutor(NodeExecutorBase):
     """
     범용 노드 실행기 (커뮤니티 노드 및 execute() 메서드가 있는 노드용)
@@ -10275,7 +10529,18 @@ class MarketDataNodeExecutor(NodeExecutorBase):
             return _df.apply_override(fixture, override)
 
         if not symbols:
-            error_msg = "symbols 필드가 필수입니다. 종목을 직접 입력하거나 WatchlistNode를 연결하세요."
+            # D2: 상류(조건/필터)가 이번 실행에서 빈 목록을 낸 정상 케이스는 error 없이 빈
+            # values 로 흘린다(오늘 조회할 종목 없음). 소스 미연결/미해석만 종전 error.
+            kind, detail = classify_empty_symbol_source(
+                node_id, config, context, kwargs.get("workflow"), keys=("symbol", "symbols")
+            )
+            if kind == EMPTY_SYMBOLS_NO_SIGNAL:
+                context.log("info", f"No symbols to quote in this run — {detail}", node_id)
+                return {"values": []}
+            error_msg = (
+                "symbols 필드가 필수입니다. 종목을 직접 입력하거나 WatchlistNode를 연결하세요. "
+                f"({detail})"
+            )
             context.log("error", error_msg, node_id)
             return {"error": error_msg, "values": []}
 
@@ -10340,6 +10605,7 @@ class MarketDataNodeExecutor(NodeExecutorBase):
             values = []
             
             for symbol_entry in symbols:
+                exchange, symbol = "", ""  # handler-safe defaults: the except below must never touch an unassigned name (UnboundLocalError masked the real cause)
                 try:
                     # 거래소와 심볼 추출
                     exchange = symbol_entry.get("exchange", "NASDAQ")
@@ -10414,7 +10680,7 @@ class MarketDataNodeExecutor(NodeExecutorBase):
                         context.log("warning", f"No data for {exchange}:{symbol}", node_id)
                         
                 except Exception as e:
-                    context.log("warning", f"Failed to fetch {exchange}:{symbol}: {e}", node_id)
+                    context.log("warning", f"Failed to fetch {exchange}:{symbol or symbol_entry!r}: {e}", node_id)
                     continue
             
             return {"values": values}
@@ -10459,6 +10725,7 @@ class MarketDataNodeExecutor(NodeExecutorBase):
             values = []
             
             for symbol_entry in symbols:
+                exchange, symbol = "", ""  # handler-safe defaults: the except below must never touch an unassigned name (UnboundLocalError masked the real cause)
                 try:
                     # 해외선물은 exchange 대신 symbol만 사용 (예: "GCGF25", "CLH25")
                     exchange = symbol_entry.get("exchange", "CME")
@@ -10499,7 +10766,7 @@ class MarketDataNodeExecutor(NodeExecutorBase):
                         context.log("warning", f"No data for {exchange}:{symbol}", node_id)
                         
                 except Exception as e:
-                    context.log("warning", f"Failed to fetch {exchange}:{symbol}: {e}", node_id)
+                    context.log("warning", f"Failed to fetch {exchange}:{symbol or symbol_entry!r}: {e}", node_id)
                     continue
             
             return {"values": values}
@@ -10544,6 +10811,7 @@ class MarketDataNodeExecutor(NodeExecutorBase):
             values = []
 
             for symbol_entry in symbols:
+                symbol = ""  # handler-safe default: the except below must never touch an unassigned name (UnboundLocalError masked the real cause)
                 try:
                     symbol = symbol_entry.get("symbol", "")
                     if not symbol:
@@ -10583,7 +10851,7 @@ class MarketDataNodeExecutor(NodeExecutorBase):
                         context.log("warning", f"No data for KRX:{symbol}", node_id)
 
                 except Exception as e:
-                    context.log("warning", f"Failed to fetch KRX:{symbol}: {e}", node_id)
+                    context.log("warning", f"Failed to fetch KRX:{symbol or symbol_entry!r}: {e}", node_id)
                     continue
 
             return {"values": values}
@@ -10644,7 +10912,17 @@ class FundamentalNodeExecutor(NodeExecutorBase):
                 symbols = [config_symbol]
 
         if not symbols:
-            error_msg = "symbols 필드가 필수입니다. 종목을 직접 입력하거나 WatchlistNode를 연결하세요."
+            # D2: MarketDataNodeExecutor 와 같은 3분류 — 정상 no-signal 은 error 없이 빈 values.
+            kind, detail = classify_empty_symbol_source(
+                node_id, config, context, kwargs.get("workflow"), keys=("symbol", "symbols")
+            )
+            if kind == EMPTY_SYMBOLS_NO_SIGNAL:
+                context.log("info", f"No symbols to look up in this run — {detail}", node_id)
+                return {"values": []}
+            error_msg = (
+                "symbols 필드가 필수입니다. 종목을 직접 입력하거나 WatchlistNode를 연결하세요. "
+                f"({detail})"
+            )
             context.log("error", error_msg, node_id)
             return {"error": error_msg, "values": []}
 
@@ -10690,6 +10968,7 @@ class FundamentalNodeExecutor(NodeExecutorBase):
             values = []
 
             for symbol_entry in symbols:
+                exchange, symbol = "", ""  # handler-safe defaults: the except below must never touch an unassigned name (UnboundLocalError masked the real cause)
                 try:
                     exchange = symbol_entry.get("exchange", "NASDAQ")
                     symbol = symbol_entry.get("symbol", "")
@@ -10739,7 +11018,7 @@ class FundamentalNodeExecutor(NodeExecutorBase):
                         context.log("warning", f"No data for {exchange}:{symbol}", node_id)
 
                 except Exception as e:
-                    context.log("warning", f"Failed to fetch {exchange}:{symbol}: {e}", node_id)
+                    context.log("warning", f"Failed to fetch {exchange}:{symbol or symbol_entry!r}: {e}", node_id)
                     continue
 
             return {"values": values}
@@ -10780,6 +11059,7 @@ class FundamentalNodeExecutor(NodeExecutorBase):
             values = []
 
             for symbol_entry in symbols:
+                symbol = ""  # handler-safe default: the except below must never touch an unassigned name (UnboundLocalError masked the real cause)
                 try:
                     symbol = symbol_entry.get("symbol", "")
                     if not symbol:
@@ -10812,7 +11092,7 @@ class FundamentalNodeExecutor(NodeExecutorBase):
                         context.log("warning", f"No data for KRX:{symbol}", node_id)
 
                 except Exception as e:
-                    context.log("warning", f"Failed to fetch KRX:{symbol}: {e}", node_id)
+                    context.log("warning", f"Failed to fetch KRX:{symbol or symbol_entry!r}: {e}", node_id)
                     continue
 
             return {"values": values}
@@ -10998,7 +11278,16 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
             # / ConditionNode 의 `item.time_series`)이 조용히 None 이 되고 방어적
             # `data or []` 가 그걸 삼켜 에러 없이 빈 결과(count:0)를 낸다.
             # (deep_fixtures.historical_data_fixture 도 이 스키마를 못박는다.)
-            context.log("warning", "No symbols provided", node_id)
+            # D2: 상류 배열이 비어 반복이 없었던 것(정상 no-signal)은 info, 소스 미연결/
+            # 미해석 바인딩(설계 결함)만 warning("No symbols provided …") — 챗봇 저장
+            # 게이트가 이 문구를 결함으로 읽으므로 정상 케이스에는 찍지 않는다.
+            kind, detail = classify_empty_symbol_source(
+                node_id, config, context, kwargs.get("workflow"), keys=("symbol", "symbols")
+            )
+            if kind == EMPTY_SYMBOLS_NO_SIGNAL:
+                context.log("info", f"No symbols to fetch in this run — {detail}", node_id)
+            else:
+                context.log("warning", f"No symbols provided — {detail}", node_id)
             return {
                 "value": None,
                 "values": [],
@@ -12757,18 +13046,45 @@ class PositionSizingNodeExecutor(NodeExecutorBase):
         kelly_fraction = float(evaluated.get("kelly_fraction", 0.25))
         atr_risk_percent = float(evaluated.get("atr_risk_percent", 1.0))
         
+        # 상류가 error 신호를 동봉한 dict(예: `{"error": …, "values": []}`)를 symbols 로
+        # 넘겼으면 fetch_failed. 정규화 **전에** 본다 — `_normalize_symbols` 의 dict 분기는
+        # `{종목: {...}}` 맵 전용이라, error 페이로드를 넣으면 "error"/"values" 라는 가짜
+        # 종목 2건이 만들어져 사이징이 그대로 진행됐다(빈-목록 분기에 영영 안 닿음).
+        if isinstance(symbols_input, dict) and symbols_input.get("error"):
+            err = str(symbols_input.get("error"))
+            context.log(
+                "warning",
+                f"No symbols provided for position sizing — upstream fetch failed: {err}",
+                node_id,
+            )
+            return self._empty_result(EmptyOrderReason.FETCH_FAILED, err)
+
         # 종목 리스트 정규화
         symbols = self._normalize_symbols(symbols_input)
         
         if not symbols:
-            context.log("warning", "No symbols provided for position sizing", node_id)
-            # 상류가 빈 리스트에 error 신호를 동봉했으면 fetch_failed, 아니면 종목 미지정.
-            err = None
-            if isinstance(symbols_input, dict) and symbols_input.get("error"):
-                err = str(symbols_input.get("error"))
-            if err:
-                return self._empty_result(EmptyOrderReason.FETCH_FAILED, err)
-            return self._empty_result(EmptyOrderReason.NO_SYMBOL, "")
+            # D2: "오늘 신호 없음(정상)" 과 "종목 소스 미연결/미해석(설계 결함)" 을 가른다.
+            # 전자는 warning 을 찍지 않는다 — 챗봇 저장 게이트가 "No symbols provided" 를
+            # 설계 결함으로 읽어, 올바로 배선된 워크플로우가 모의 실행 표본에서 조건 통과
+            # 종목이 0 이라는 이유만으로 저장되지 못했다(벤치 본선 최대 실패 원인).
+            kind, detail = classify_empty_symbol_source(
+                node_id, evaluated, context, kwargs.get("workflow"), keys=("symbols", "symbol")
+            )
+            if kind == EMPTY_SYMBOLS_NO_SIGNAL:
+                context.log(
+                    "info",
+                    f"No symbols to size in this run — {detail}; sizing skipped",
+                    node_id,
+                )
+                return self._empty_result(EmptyOrderReason.NO_SIGNAL, detail)
+            context.log(
+                "warning",
+                f"No symbols provided for position sizing — {detail}",
+                node_id,
+            )
+            if kind == EMPTY_SYMBOLS_UPSTREAM_FAILED:
+                return self._empty_result(EmptyOrderReason.FETCH_FAILED, detail)
+            return self._empty_result(EmptyOrderReason.NO_SYMBOL, detail)
         
         # Refuse to silently zero-out when the upstream AccountNode flagged
         # a partial fetch. fixed_quantity ignores balance entirely, so it
@@ -12812,6 +13128,18 @@ class PositionSizingNodeExecutor(NodeExecutorBase):
                     or "balance fetch partially failed"
                 )
                 return self._empty_result(EmptyOrderReason.FETCH_FAILED, detail)
+            # 잔고 입력 자체가 없거나 미해석(`{{ … }}` 리터럴) = 읽지 못한 것이지 "오늘
+            # 신호 없음" 이 아니다. 종목은 있는데 잔고가 안 묶인 채 no_signal 로 흘리면
+            # 하류 주문 노드(D2 상속)까지 조용한 no-op 이 된다. 실제로 잔고 dict 가 있고
+            # 매수가능금액이 0 인 경우만 정상 no_signal(현금 없음).
+            if balance_data in (None, "", {}, [], ()) or (
+                isinstance(balance_data, str) and "{{" in balance_data
+            ):
+                return self._empty_result(
+                    EmptyOrderReason.FETCH_FAILED,
+                    "balance input is missing or unresolved — bind `balance` to "
+                    "AccountNode.balance (every sizing method except fixed_quantity needs it)",
+                )
             return self._empty_result(
                 EmptyOrderReason.NO_SIGNAL,
                 "No available balance for position sizing",
@@ -13914,7 +14242,7 @@ class NewOrderNodeExecutor(NodeExecutorBase):
         if not normalized_order:
             context.log("warning", f"{node_type}: 주문할 종목이 없습니다", node_id)
             reason, detail = self._diagnose_empty_reason(
-                order, config, raw_order_expr, context
+                order, config, raw_order_expr, context, node_id=node_id
             )
             return self._empty_result(reason, detail)
 
@@ -14144,6 +14472,7 @@ class NewOrderNodeExecutor(NodeExecutorBase):
         config: Dict[str, Any],
         raw_order_expr: Any = None,
         context: Optional[ExecutionContext] = None,
+        node_id: Optional[str] = None,
     ) -> tuple:
         """빈 주문 결과의 reason 을 상류 신호로 판정.
 
@@ -14194,6 +14523,23 @@ class NewOrderNodeExecutor(NodeExecutorBase):
             if err is not None:
                 return EmptyOrderReason.FETCH_FAILED, err
 
+        # 3.5) 상류가 명시적으로 "오늘 신호 없음"(reason=no_signal) 을 냈으면 정상 no-op.
+        #      D2(벤치 2026-09-06): 사이징이 빈 종목 목록(조건 미통과)을 받아 orders=[] 를
+        #      내면 주문 노드는 order=None 을 받는데, 아래 5) 가 그걸 "종목 미지정(no_symbol)"
+        #      으로 분류해 `_order_failure_from_outputs` 가 매 실행 "설정 누락" 으로 보고했다.
+        #      상류의 no_signal 은 실패 신호(error/_partial_failure/fetch_failed)가 없을 때만
+        #      그대로 물려받는다.
+        for candidate in (upstream, _input_namespace(context, node_id) if (context is not None and node_id) else None):
+            if (
+                isinstance(candidate, dict)
+                and candidate.get("reason") == EmptyOrderReason.NO_SIGNAL.value
+                and self._extract_upstream_error(candidate) is None
+            ):
+                return (
+                    EmptyOrderReason.NO_SIGNAL,
+                    str(candidate.get("detail") or candidate.get("message") or ""),
+                )
+
         # 4) 상류가 낸 빈 리스트에 실패 신호 동봉 → 조회 실패(파이프라인 고장).
         #    order/symbols 바인딩 결과가 dict 이면서 error/_partial_failure/
         #    reason='fetch_failed' 를 들고 있는 경우를 본다.

{programgarden-1.33.2 → programgarden-1.33.4}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.33.2"
+version = "1.33.4"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -30,7 +30,7 @@ pytickersymbols = {version = ">=1.17.5", python = ">=3.12,<4.0"}
 aiosqlite = "^0.20.0"
 litellm = ">=1.40.0"
 programgarden-core = "^1.25.0"
-programgarden-finance = "^1.9.1"
+programgarden-finance = "^1.9.3"
 programgarden-community = "^1.15.0"
 
 [tool.poetry.group.dev.dependencies]